bfd/opncls.c

   1 /* opncls.c -- open and close a BFD.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013
   4    Free Software Foundation, Inc.
   5
   6    Written by Cygnus Support.
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  23    MA 02110-1301, USA.  */
  24
  25 #include "sysdep.h"
  26 #include "bfd.h"
  27 #include "objalloc.h"
  28 #include "libbfd.h"
  29 #include "libiberty.h"
  30
  31 #ifndef S_IXUSR
  32 #define S_IXUSR 0100    /* Execute by owner.  */
  33 #endif
  34 #ifndef S_IXGRP
  35 #define S_IXGRP 0010    /* Execute by group.  */
  36 #endif
  37 #ifndef S_IXOTH
  38 #define S_IXOTH 0001    /* Execute by others.  */
  39 #endif
  40
  41 /* Counters used to initialize the bfd identifier.  */
  42
  43 static unsigned int bfd_id_counter = 0;
  44 static unsigned int bfd_reserved_id_counter = 0;
  45
  46 /*
  47 CODE_FRAGMENT
  48 .{* Set to N to open the next N BFDs using an alternate id space.  *}
  49 .extern unsigned int bfd_use_reserved_id;
  50 */
  51 unsigned int bfd_use_reserved_id = 0;
  52
  53 /* fdopen is a loser -- we should use stdio exclusively.  Unfortunately
  54    if we do that we can't use fcntl.  */
  55
  56 /* Return a new BFD.  All BFD's are allocated through this routine.  */
  57
  58 bfd *
  59 _bfd_new_bfd (void)
  60 {
  61   bfd *nbfd;
  62
  63   nbfd = (bfd *) bfd_zmalloc (sizeof (bfd));
  64   if (nbfd == NULL)
  65     return NULL;
  66
  67   if (bfd_use_reserved_id)
  68     {
  69       nbfd->id = --bfd_reserved_id_counter;
  70       --bfd_use_reserved_id;
  71     }
  72   else
  73     nbfd->id = bfd_id_counter++;
  74
  75   nbfd->memory = objalloc_create ();
  76   if (nbfd->memory == NULL)
  77     {
  78       bfd_set_error (bfd_error_no_memory);
  79       free (nbfd);
  80       return NULL;
  81     }
  82
  83   nbfd->arch_info = &bfd_default_arch_struct;
  84
  85   nbfd->direction = no_direction;
  86   nbfd->iostream = NULL;
  87   nbfd->where = 0;
  88   if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
  89                               sizeof (struct section_hash_entry), 13))
  90     {
  91       free (nbfd);
  92       return NULL;
  93     }
  94   nbfd->sections = NULL;
  95   nbfd->section_last = NULL;
  96   nbfd->format = bfd_unknown;
  97   nbfd->my_archive = NULL;
  98   nbfd->origin = 0;
  99   nbfd->opened_once = FALSE;
 100   nbfd->output_has_begun = FALSE;
 101   nbfd->section_count = 0;
 102   nbfd->usrdata = NULL;
 103   nbfd->cacheable = FALSE;
 104   nbfd->flags = BFD_NO_FLAGS;
 105   nbfd->mtime_set = FALSE;
 106
 107   return nbfd;
 108 }
 109
 110 static const struct bfd_iovec opncls_iovec;
 111
 112 /* Allocate a new BFD as a member of archive OBFD.  */
 113
 114 bfd *
 115 _bfd_new_bfd_contained_in (bfd *obfd)
 116 {
 117   bfd *nbfd;
 118
 119   nbfd = _bfd_new_bfd ();
 120   if (nbfd == NULL)
 121     return NULL;
 122   nbfd->xvec = obfd->xvec;
 123   nbfd->iovec = obfd->iovec;
 124   if (obfd->iovec == &opncls_iovec)
 125     nbfd->iostream = obfd->iostream;
 126   nbfd->my_archive = obfd;
 127   nbfd->direction = read_direction;
 128   nbfd->target_defaulted = obfd->target_defaulted;
 129   return nbfd;
 130 }
 131
 132 /* Delete a BFD.  */
 133
 134 static void
 135 _bfd_delete_bfd (bfd *abfd)
 136 {
 137   if (abfd->memory)
 138     {
 139       bfd_hash_table_free (&abfd->section_htab);
 140       objalloc_free ((struct objalloc *) abfd->memory);
 141     }
 142
 143   free (abfd->arelt_data);
 144   free (abfd);
 145 }
 146
 147 /* Free objalloc memory.  */
 148
 149 bfd_boolean
 150 _bfd_free_cached_info (bfd *abfd)
 151 {
 152   if (abfd->memory)
 153     {
 154       bfd_hash_table_free (&abfd->section_htab);
 155       objalloc_free ((struct objalloc *) abfd->memory);
 156
 157       abfd->sections = NULL;
 158       abfd->section_last = NULL;
 159       abfd->outsymbols = NULL;
 160       abfd->tdata.any = NULL;
 161       abfd->usrdata = NULL;
 162       abfd->memory = NULL;
 163     }
 164
 165   return TRUE;
 166 }
 167
 168 /*
 169 SECTION
 170         Opening and closing BFDs
 171
 172 SUBSECTION
 173         Functions for opening and closing
 174 */
 175
 176 /*
 177 FUNCTION
 178         bfd_fopen
 179
 180 SYNOPSIS
 181         bfd *bfd_fopen (const char *filename, const char *target,
 182                         const char *mode, int fd);
 183
 184 DESCRIPTION
 185         Open the file @var{filename} with the target @var{target}.
 186         Return a pointer to the created BFD.  If @var{fd} is not -1,
 187         then <<fdopen>> is used to open the file; otherwise, <<fopen>>
 188         is used.  @var{mode} is passed directly to <<fopen>> or
 189         <<fdopen>>.
 190
 191         Calls <<bfd_find_target>>, so @var{target} is interpreted as by
 192         that function.
 193
 194         The new BFD is marked as cacheable iff @var{fd} is -1.
 195
 196         If <<NULL>> is returned then an error has occured.   Possible errors
 197         are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
 198         <<system_call>> error.
 199
 200         On error, @var{fd} is always closed.
 201 */
 202
 203 bfd *
 204 bfd_fopen (const char *filename, const char *target, const char *mode, int fd)
 205 {
 206   bfd *nbfd;
 207   const bfd_target *target_vec;
 208
 209   nbfd = _bfd_new_bfd ();
 210   if (nbfd == NULL)
 211     {
 212       if (fd != -1)
 213         close (fd);
 214       return NULL;
 215     }
 216
 217   target_vec = bfd_find_target (target, nbfd);
 218   if (target_vec == NULL)
 219     {
 220       if (fd != -1)
 221         close (fd);
 222       _bfd_delete_bfd (nbfd);
 223       return NULL;
 224     }
 225
 226 #ifdef HAVE_FDOPEN
 227   if (fd != -1)
 228     nbfd->iostream = fdopen (fd, mode);
 229   else
 230 #endif
 231     nbfd->iostream = real_fopen (filename, mode);
 232   if (nbfd->iostream == NULL)
 233     {
 234       bfd_set_error (bfd_error_system_call);
 235       _bfd_delete_bfd (nbfd);
 236       return NULL;
 237     }
 238
 239   /* OK, put everything where it belongs.  */
 240   nbfd->filename = filename;
 241
 242   /* Figure out whether the user is opening the file for reading,
 243      writing, or both, by looking at the MODE argument.  */
 244   if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')
 245       && mode[1] == '+')
 246     nbfd->direction = both_direction;
 247   else if (mode[0] == 'r')
 248     nbfd->direction = read_direction;
 249   else
 250     nbfd->direction = write_direction;
 251
 252   if (! bfd_cache_init (nbfd))
 253     {
 254       _bfd_delete_bfd (nbfd);
 255       return NULL;
 256     }
 257   nbfd->opened_once = TRUE;
 258   /* If we opened the file by name, mark it cacheable; we can close it
 259      and reopen it later.  However, if a file descriptor was provided,
 260      then it may have been opened with special flags that make it
 261      unsafe to close and reopen the file.  */
 262   if (fd == -1)
 263     bfd_set_cacheable (nbfd, TRUE);
 264
 265   return nbfd;
 266 }
 267
 268 /*
 269 FUNCTION
 270         bfd_openr
 271
 272 SYNOPSIS
 273         bfd *bfd_openr (const char *filename, const char *target);
 274
 275 DESCRIPTION
 276         Open the file @var{filename} (using <<fopen>>) with the target
 277         @var{target}.  Return a pointer to the created BFD.
 278
 279         Calls <<bfd_find_target>>, so @var{target} is interpreted as by
 280         that function.
 281
 282         If <<NULL>> is returned then an error has occured.   Possible errors
 283         are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
 284         <<system_call>> error.
 285 */
 286
 287 bfd *
 288 bfd_openr (const char *filename, const char *target)
 289 {
 290   return bfd_fopen (filename, target, FOPEN_RB, -1);
 291 }
 292
 293 /* Don't try to `optimize' this function:
 294
 295    o - We lock using stack space so that interrupting the locking
 296        won't cause a storage leak.
 297    o - We open the file stream last, since we don't want to have to
 298        close it if anything goes wrong.  Closing the stream means closing
 299        the file descriptor too, even though we didn't open it.  */
 300 /*
 301 FUNCTION
 302         bfd_fdopenr
 303
 304 SYNOPSIS
 305         bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
 306
 307 DESCRIPTION
 308         <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
 309         <<fopen>>.  It opens a BFD on a file already described by the
 310         @var{fd} supplied.
 311
 312         When the file is later <<bfd_close>>d, the file descriptor will
 313         be closed.  If the caller desires that this file descriptor be
 314         cached by BFD (opened as needed, closed as needed to free
 315         descriptors for other opens), with the supplied @var{fd} used as
 316         an initial file descriptor (but subject to closure at any time),
 317         call bfd_set_cacheable(bfd, 1) on the returned BFD.  The default
 318         is to assume no caching; the file descriptor will remain open
 319         until <<bfd_close>>, and will not be affected by BFD operations
 320         on other files.
 321
 322         Possible errors are <<bfd_error_no_memory>>,
 323         <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
 324
 325         On error, @var{fd} is closed.
 326 */
 327
 328 bfd *
 329 bfd_fdopenr (const char *filename, const char *target, int fd)
 330 {
 331   const char *mode;
 332 #if defined(HAVE_FCNTL) && defined(F_GETFL)
 333   int fdflags;
 334 #endif
 335
 336 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
 337   mode = FOPEN_RUB; /* Assume full access.  */
 338 #else
 339   fdflags = fcntl (fd, F_GETFL, NULL);
 340   if (fdflags == -1)
 341     {
 342       int save = errno;
 343
 344       close (fd);
 345       errno = save;
 346       bfd_set_error (bfd_error_system_call);
 347       return NULL;
 348     }
 349
 350   /* (O_ACCMODE) parens are to avoid Ultrix header file bug.  */
 351   switch (fdflags & (O_ACCMODE))
 352     {
 353     case O_RDONLY: mode = FOPEN_RB; break;
 354     case O_WRONLY: mode = FOPEN_RUB; break;
 355     case O_RDWR:   mode = FOPEN_RUB; break;
 356     default: abort ();
 357     }
 358 #endif
 359
 360   return bfd_fopen (filename, target, mode, fd);
 361 }
 362
 363 /*
 364 FUNCTION
 365         bfd_openstreamr
 366
 367 SYNOPSIS
 368         bfd *bfd_openstreamr (const char *, const char *, void *);
 369
 370 DESCRIPTION
 371
 372         Open a BFD for read access on an existing stdio stream.  When
 373         the BFD is passed to <<bfd_close>>, the stream will be closed.
 374 */
 375
 376 bfd *
 377 bfd_openstreamr (const char *filename, const char *target, void *streamarg)
 378 {
 379   FILE *stream = (FILE *) streamarg;
 380   bfd *nbfd;
 381   const bfd_target *target_vec;
 382
 383   nbfd = _bfd_new_bfd ();
 384   if (nbfd == NULL)
 385     return NULL;
 386
 387   target_vec = bfd_find_target (target, nbfd);
 388   if (target_vec == NULL)
 389     {
 390       _bfd_delete_bfd (nbfd);
 391       return NULL;
 392     }
 393
 394   nbfd->iostream = stream;
 395   nbfd->filename = filename;
 396   nbfd->direction = read_direction;
 397
 398   if (! bfd_cache_init (nbfd))
 399     {
 400       _bfd_delete_bfd (nbfd);
 401       return NULL;
 402     }
 403
 404   return nbfd;
 405 }
 406
 407 /*
 408 FUNCTION
 409         bfd_openr_iovec
 410
 411 SYNOPSIS
 412         bfd *bfd_openr_iovec (const char *filename, const char *target,
 413                               void *(*open_func) (struct bfd *nbfd,
 414                                                   void *open_closure),
 415                               void *open_closure,
 416                               file_ptr (*pread_func) (struct bfd *nbfd,
 417                                                       void *stream,
 418                                                       void *buf,
 419                                                       file_ptr nbytes,
 420                                                       file_ptr offset),
 421                               int (*close_func) (struct bfd *nbfd,
 422                                                  void *stream),
 423                               int (*stat_func) (struct bfd *abfd,
 424                                                 void *stream,
 425                                                 struct stat *sb));
 426
 427 DESCRIPTION
 428
 429         Create and return a BFD backed by a read-only @var{stream}.
 430         The @var{stream} is created using @var{open_func}, accessed using
 431         @var{pread_func} and destroyed using @var{close_func}.
 432
 433         Calls <<bfd_find_target>>, so @var{target} is interpreted as by
 434         that function.
 435
 436         Calls @var{open_func} (which can call <<bfd_zalloc>> and
 437         <<bfd_get_filename>>) to obtain the read-only stream backing
 438         the BFD.  @var{open_func} either succeeds returning the
 439         non-<<NULL>> @var{stream}, or fails returning <<NULL>>
 440         (setting <<bfd_error>>).
 441
 442         Calls @var{pread_func} to request @var{nbytes} of data from
 443         @var{stream} starting at @var{offset} (e.g., via a call to
 444         <<bfd_read>>).  @var{pread_func} either succeeds returning the
 445         number of bytes read (which can be less than @var{nbytes} when
 446         end-of-file), or fails returning -1 (setting <<bfd_error>>).
 447
 448         Calls @var{close_func} when the BFD is later closed using
 449         <<bfd_close>>.  @var{close_func} either succeeds returning 0, or
 450         fails returning -1 (setting <<bfd_error>>).
 451
 452         Calls @var{stat_func} to fill in a stat structure for bfd_stat,
 453         bfd_get_size, and bfd_get_mtime calls.  @var{stat_func} returns 0
 454         on success, or returns -1 on failure (setting <<bfd_error>>).
 455
 456         If <<bfd_openr_iovec>> returns <<NULL>> then an error has
 457         occurred.  Possible errors are <<bfd_error_no_memory>>,
 458         <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
 459
 460 */
 461
 462 struct opncls
 463 {
 464   void *stream;
 465   file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,
 466                      file_ptr nbytes, file_ptr offset);
 467   int (*close) (struct bfd *abfd, void *stream);
 468   int (*stat) (struct bfd *abfd, void *stream, struct stat *sb);
 469   file_ptr where;
 470 };
 471
 472 static file_ptr
 473 opncls_btell (struct bfd *abfd)
 474 {
 475   struct opncls *vec = (struct opncls *) abfd->iostream;
 476   return vec->where;
 477 }
 478
 479 static int
 480 opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)
 481 {
 482   struct opncls *vec = (struct opncls *) abfd->iostream;
 483   switch (whence)
 484     {
 485     case SEEK_SET: vec->where = offset; break;
 486     case SEEK_CUR: vec->where += offset; break;
 487     case SEEK_END: return -1;
 488     }
 489   return 0;
 490 }
 491
 492 static file_ptr
 493 opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
 494 {
 495   struct opncls *vec = (struct opncls *) abfd->iostream;
 496   file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where);
 497   if (nread < 0)
 498     return nread;
 499   vec->where += nread;
 500   return nread;
 501 }
 502
 503 static file_ptr
 504 opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
 505               const void *where ATTRIBUTE_UNUSED,
 506               file_ptr nbytes ATTRIBUTE_UNUSED)
 507 {
 508   return -1;
 509 }
 510
 511 static int
 512 opncls_bclose (struct bfd *abfd)
 513 {
 514   struct opncls *vec = (struct opncls *) abfd->iostream;
 515   /* Since the VEC's memory is bound to the bfd deleting the bfd will
 516      free it.  */
 517   int status = 0;
 518   if (vec->close != NULL)
 519     status = (vec->close) (abfd, vec->stream);
 520   abfd->iostream = NULL;
 521   return status;
 522 }
 523
 524 static int
 525 opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
 526 {
 527   return 0;
 528 }
 529
 530 static int
 531 opncls_bstat (struct bfd *abfd, struct stat *sb)
 532 {
 533   struct opncls *vec = (struct opncls *) abfd->iostream;
 534
 535   memset (sb, 0, sizeof (*sb));
 536   if (vec->stat == NULL)
 537     return 0;
 538
 539   return (vec->stat) (abfd, vec->stream, sb);
 540 }
 541
 542 static void *
 543 opncls_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
 544               void *addr ATTRIBUTE_UNUSED,
 545               bfd_size_type len ATTRIBUTE_UNUSED,
 546               int prot ATTRIBUTE_UNUSED,
 547               int flags ATTRIBUTE_UNUSED,
 548               file_ptr offset ATTRIBUTE_UNUSED,
 549               void **map_addr ATTRIBUTE_UNUSED,
 550               bfd_size_type *map_len ATTRIBUTE_UNUSED)
 551 {
 552   return (void *) -1;
 553 }
 554
 555 static const struct bfd_iovec opncls_iovec = {
 556   &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
 557   &opncls_bclose, &opncls_bflush, &opncls_bstat, &opncls_bmmap
 558 };
 559
 560 bfd *
 561 bfd_openr_iovec (const char *filename, const char *target,
 562                  void *(*open_p) (struct bfd *, void *),
 563                  void *open_closure,
 564                  file_ptr (*pread_p) (struct bfd *, void *, void *,
 565                                       file_ptr, file_ptr),
 566                  int (*close_p) (struct bfd *, void *),
 567                  int (*stat_p) (struct bfd *, void *, struct stat *))
 568 {
 569   bfd *nbfd;
 570   const bfd_target *target_vec;
 571   struct opncls *vec;
 572   void *stream;
 573
 574   nbfd = _bfd_new_bfd ();
 575   if (nbfd == NULL)
 576     return NULL;
 577
 578   target_vec = bfd_find_target (target, nbfd);
 579   if (target_vec == NULL)
 580     {
 581       _bfd_delete_bfd (nbfd);
 582       return NULL;
 583     }
 584
 585   nbfd->filename = filename;
 586   nbfd->direction = read_direction;
 587
 588   /* `open_p (...)' would get expanded by an the open(2) syscall macro.  */
 589   stream = (*open_p) (nbfd, open_closure);
 590   if (stream == NULL)
 591     {
 592       _bfd_delete_bfd (nbfd);
 593       return NULL;
 594     }
 595
 596   vec = (struct opncls *) bfd_zalloc (nbfd, sizeof (struct opncls));
 597   vec->stream = stream;
 598   vec->pread = pread_p;
 599   vec->close = close_p;
 600   vec->stat = stat_p;
 601
 602   nbfd->iovec = &opncls_iovec;
 603   nbfd->iostream = vec;
 604
 605   return nbfd;
 606 }
 607 \f
 608 /* bfd_openw -- open for writing.
 609    Returns a pointer to a freshly-allocated BFD on success, or NULL.
 610
 611    See comment by bfd_fdopenr before you try to modify this function.  */
 612
 613 /*
 614 FUNCTION
 615         bfd_openw
 616
 617 SYNOPSIS
 618         bfd *bfd_openw (const char *filename, const char *target);
 619
 620 DESCRIPTION
 621         Create a BFD, associated with file @var{filename}, using the
 622         file format @var{target}, and return a pointer to it.
 623
 624         Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
 625         <<bfd_error_invalid_target>>.
 626 */
 627
 628 bfd *
 629 bfd_openw (const char *filename, const char *target)
 630 {
 631   bfd *nbfd;
 632   const bfd_target *target_vec;
 633
 634   /* nbfd has to point to head of malloc'ed block so that bfd_close may
 635      reclaim it correctly.  */
 636   nbfd = _bfd_new_bfd ();
 637   if (nbfd == NULL)
 638     return NULL;
 639
 640   target_vec = bfd_find_target (target, nbfd);
 641   if (target_vec == NULL)
 642     {
 643       _bfd_delete_bfd (nbfd);
 644       return NULL;
 645     }
 646
 647   nbfd->filename = filename;
 648   nbfd->direction = write_direction;
 649
 650   if (bfd_open_file (nbfd) == NULL)
 651     {
 652       /* File not writeable, etc.  */
 653       bfd_set_error (bfd_error_system_call);
 654       _bfd_delete_bfd (nbfd);
 655       return NULL;
 656   }
 657
 658   return nbfd;
 659 }
 660
 661 static inline void
 662 _maybe_make_executable (bfd * abfd)
 663 {
 664   /* If the file was open for writing and is now executable,
 665      make it so.  */
 666   if (abfd->direction == write_direction
 667       && (abfd->flags & (EXEC_P | DYNAMIC)) != 0)
 668     {
 669       struct stat buf;
 670
 671       if (stat (abfd->filename, &buf) == 0
 672           /* Do not attempt to change non-regular files.  This is
 673              here especially for configure scripts and kernel builds
 674              which run tests with "ld [...] -o /dev/null".  */
 675           && S_ISREG(buf.st_mode))
 676         {
 677           unsigned int mask = umask (0);
 678
 679           umask (mask);
 680           chmod (abfd->filename,
 681                  (0777
 682                   & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
 683         }
 684     }
 685 }
 686
 687 /*
 688
 689 FUNCTION
 690         bfd_close
 691
 692 SYNOPSIS
 693         bfd_boolean bfd_close (bfd *abfd);
 694
 695 DESCRIPTION
 696
 697         Close a BFD. If the BFD was open for writing, then pending
 698         operations are completed and the file written out and closed.
 699         If the created file is executable, then <<chmod>> is called
 700         to mark it as such.
 701
 702         All memory attached to the BFD is released.
 703
 704         The file descriptor associated with the BFD is closed (even
 705         if it was passed in to BFD by <<bfd_fdopenr>>).
 706
 707 RETURNS
 708         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 709 */
 710
 711
 712 bfd_boolean
 713 bfd_close (bfd *abfd)
 714 {
 715   bfd_boolean ret;
 716
 717   if (bfd_write_p (abfd))
 718     {
 719       if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 720         return FALSE;
 721     }
 722
 723   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 724     return FALSE;
 725
 726   ret = abfd->iovec->bclose (abfd) == 0;
 727
 728   if (ret)
 729     _maybe_make_executable (abfd);
 730
 731   _bfd_delete_bfd (abfd);
 732
 733   return ret;
 734 }
 735
 736 /*
 737 FUNCTION
 738         bfd_close_all_done
 739
 740 SYNOPSIS
 741         bfd_boolean bfd_close_all_done (bfd *);
 742
 743 DESCRIPTION
 744         Close a BFD.  Differs from <<bfd_close>> since it does not
 745         complete any pending operations.  This routine would be used
 746         if the application had just used BFD for swapping and didn't
 747         want to use any of the writing code.
 748
 749         If the created file is executable, then <<chmod>> is called
 750         to mark it as such.
 751
 752         All memory attached to the BFD is released.
 753
 754 RETURNS
 755         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 756 */
 757
 758 bfd_boolean
 759 bfd_close_all_done (bfd *abfd)
 760 {
 761   bfd_boolean ret;
 762
 763   ret = bfd_cache_close (abfd);
 764
 765   if (ret)
 766     _maybe_make_executable (abfd);
 767
 768   _bfd_delete_bfd (abfd);
 769
 770   return ret;
 771 }
 772
 773 /*
 774 FUNCTION
 775         bfd_create
 776
 777 SYNOPSIS
 778         bfd *bfd_create (const char *filename, bfd *templ);
 779
 780 DESCRIPTION
 781         Create a new BFD in the manner of <<bfd_openw>>, but without
 782         opening a file. The new BFD takes the target from the target
 783         used by @var{templ}. The format is always set to <<bfd_object>>.
 784 */
 785
 786 bfd *
 787 bfd_create (const char *filename, bfd *templ)
 788 {
 789   bfd *nbfd;
 790
 791   nbfd = _bfd_new_bfd ();
 792   if (nbfd == NULL)
 793     return NULL;
 794   nbfd->filename = filename;
 795   if (templ)
 796     nbfd->xvec = templ->xvec;
 797   nbfd->direction = no_direction;
 798   bfd_set_format (nbfd, bfd_object);
 799
 800   return nbfd;
 801 }
 802
 803 /*
 804 FUNCTION
 805         bfd_make_writable
 806
 807 SYNOPSIS
 808         bfd_boolean bfd_make_writable (bfd *abfd);
 809
 810 DESCRIPTION
 811         Takes a BFD as created by <<bfd_create>> and converts it
 812         into one like as returned by <<bfd_openw>>.  It does this
 813         by converting the BFD to BFD_IN_MEMORY.  It's assumed that
 814         you will call <<bfd_make_readable>> on this bfd later.
 815
 816 RETURNS
 817         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 818 */
 819
 820 bfd_boolean
 821 bfd_make_writable (bfd *abfd)
 822 {
 823   struct bfd_in_memory *bim;
 824
 825   if (abfd->direction != no_direction)
 826     {
 827       bfd_set_error (bfd_error_invalid_operation);
 828       return FALSE;
 829     }
 830
 831   bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
 832   if (bim == NULL)
 833     return FALSE;       /* bfd_error already set.  */
 834   abfd->iostream = bim;
 835   /* bfd_bwrite will grow these as needed.  */
 836   bim->size = 0;
 837   bim->buffer = 0;
 838
 839   abfd->flags |= BFD_IN_MEMORY;
 840   abfd->iovec = &_bfd_memory_iovec;
 841   abfd->origin = 0;
 842   abfd->direction = write_direction;
 843   abfd->where = 0;
 844
 845   return TRUE;
 846 }
 847
 848 /*
 849 FUNCTION
 850         bfd_make_readable
 851
 852 SYNOPSIS
 853         bfd_boolean bfd_make_readable (bfd *abfd);
 854
 855 DESCRIPTION
 856         Takes a BFD as created by <<bfd_create>> and
 857         <<bfd_make_writable>> and converts it into one like as
 858         returned by <<bfd_openr>>.  It does this by writing the
 859         contents out to the memory buffer, then reversing the
 860         direction.
 861
 862 RETURNS
 863         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
 864
 865 bfd_boolean
 866 bfd_make_readable (bfd *abfd)
 867 {
 868   if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
 869     {
 870       bfd_set_error (bfd_error_invalid_operation);
 871       return FALSE;
 872     }
 873
 874   if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 875     return FALSE;
 876
 877   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 878     return FALSE;
 879
 880   abfd->arch_info = &bfd_default_arch_struct;
 881
 882   abfd->where = 0;
 883   abfd->format = bfd_unknown;
 884   abfd->my_archive = NULL;
 885   abfd->origin = 0;
 886   abfd->opened_once = FALSE;
 887   abfd->output_has_begun = FALSE;
 888   abfd->section_count = 0;
 889   abfd->usrdata = NULL;
 890   abfd->cacheable = FALSE;
 891   abfd->flags |= BFD_IN_MEMORY;
 892   abfd->mtime_set = FALSE;
 893
 894   abfd->target_defaulted = TRUE;
 895   abfd->direction = read_direction;
 896   abfd->sections = 0;
 897   abfd->symcount = 0;
 898   abfd->outsymbols = 0;
 899   abfd->tdata.any = 0;
 900
 901   bfd_section_list_clear (abfd);
 902   bfd_check_format (abfd, bfd_object);
 903
 904   return TRUE;
 905 }
 906
 907 /*
 908 FUNCTION
 909         bfd_alloc
 910
 911 SYNOPSIS
 912         void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
 913
 914 DESCRIPTION
 915         Allocate a block of @var{wanted} bytes of memory attached to
 916         <<abfd>> and return a pointer to it.
 917 */
 918
 919 void *
 920 bfd_alloc (bfd *abfd, bfd_size_type size)
 921 {
 922   void *ret;
 923
 924   if (size != (unsigned long) size)
 925     {
 926       bfd_set_error (bfd_error_no_memory);
 927       return NULL;
 928     }
 929
 930   ret = objalloc_alloc ((struct objalloc *) abfd->memory, (unsigned long) size);
 931   if (ret == NULL)
 932     bfd_set_error (bfd_error_no_memory);
 933   return ret;
 934 }
 935
 936 /*
 937 INTERNAL_FUNCTION
 938         bfd_alloc2
 939
 940 SYNOPSIS
 941         void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
 942
 943 DESCRIPTION
 944         Allocate a block of @var{nmemb} elements of @var{size} bytes each
 945         of memory attached to <<abfd>> and return a pointer to it.
 946 */
 947
 948 void *
 949 bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
 950 {
 951   void *ret;
 952
 953   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
 954       && size != 0
 955       && nmemb > ~(bfd_size_type) 0 / size)
 956     {
 957       bfd_set_error (bfd_error_no_memory);
 958       return NULL;
 959     }
 960
 961   size *= nmemb;
 962
 963   if (size != (unsigned long) size)
 964     {
 965       bfd_set_error (bfd_error_no_memory);
 966       return NULL;
 967     }
 968
 969   ret = objalloc_alloc ((struct objalloc *) abfd->memory, (unsigned long) size);
 970   if (ret == NULL)
 971     bfd_set_error (bfd_error_no_memory);
 972   return ret;
 973 }
 974
 975 /*
 976 FUNCTION
 977         bfd_zalloc
 978
 979 SYNOPSIS
 980         void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
 981
 982 DESCRIPTION
 983         Allocate a block of @var{wanted} bytes of zeroed memory
 984         attached to <<abfd>> and return a pointer to it.
 985 */
 986
 987 void *
 988 bfd_zalloc (bfd *abfd, bfd_size_type size)
 989 {
 990   void *res;
 991
 992   res = bfd_alloc (abfd, size);
 993   if (res)
 994     memset (res, 0, (size_t) size);
 995   return res;
 996 }
 997
 998 /*
 999 INTERNAL_FUNCTION
1000         bfd_zalloc2
1001
1002 SYNOPSIS
1003         void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
1004
1005 DESCRIPTION
1006         Allocate a block of @var{nmemb} elements of @var{size} bytes each
1007         of zeroed memory attached to <<abfd>> and return a pointer to it.
1008 */
1009
1010 void *
1011 bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
1012 {
1013   void *res;
1014
1015   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
1016       && size != 0
1017       && nmemb > ~(bfd_size_type) 0 / size)
1018     {
1019       bfd_set_error (bfd_error_no_memory);
1020       return NULL;
1021     }
1022
1023   size *= nmemb;
1024
1025   res = bfd_alloc (abfd, size);
1026   if (res)
1027     memset (res, 0, (size_t) size);
1028   return res;
1029 }
1030
1031 /* Free a block allocated for a BFD.
1032    Note:  Also frees all more recently allocated blocks!  */
1033
1034 void
1035 bfd_release (bfd *abfd, void *block)
1036 {
1037   objalloc_free_block ((struct objalloc *) abfd->memory, block);
1038 }
1039
1040
1041 /*
1042    GNU Extension: separate debug-info files
1043
1044    The idea here is that a special section called .gnu_debuglink might be
1045    embedded in a binary file, which indicates that some *other* file
1046    contains the real debugging information. This special section contains a
1047    filename and CRC32 checksum, which we read and resolve to another file,
1048    if it exists.
1049
1050    This facilitates "optional" provision of debugging information, without
1051    having to provide two complete copies of every binary object (with and
1052    without debug symbols).
1053 */
1054
1055 #define GNU_DEBUGLINK   ".gnu_debuglink"
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 INTERNAL_FUNCTION
1194         separate_debug_file_exists
1195
1196 SYNOPSIS
1197         bfd_boolean separate_debug_file_exists
1198           (char *name, unsigned long crc32);
1199
1200 DESCRIPTION
1201         Checks to see if @var{name} is a file and if its contents
1202         match @var{crc32}.
1203 */
1204
1205 static bfd_boolean
1206 separate_debug_file_exists (const char *name, const unsigned long crc)
1207 {
1208   static unsigned char buffer [8 * 1024];
1209   unsigned long file_crc = 0;
1210   FILE *f;
1211   bfd_size_type count;
1212
1213   BFD_ASSERT (name);
1214
1215   f = real_fopen (name, FOPEN_RB);
1216   if (f == NULL)
1217     return FALSE;
1218
1219   while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1220     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1221
1222   fclose (f);
1223
1224   return crc == file_crc;
1225 }
1226
1227
1228 /*
1229 INTERNAL_FUNCTION
1230         find_separate_debug_file
1231
1232 SYNOPSIS
1233         char *find_separate_debug_file (bfd *abfd);
1234
1235 DESCRIPTION
1236         Searches @var{abfd} for a reference to separate debugging
1237         information, scans various locations in the filesystem, including
1238         the file tree rooted at @var{debug_file_directory}, and returns a
1239         filename of such debugging information if the file is found and has
1240         matching CRC32.  Returns NULL if no reference to debugging file
1241         exists, or file cannot be found.
1242 */
1243
1244 static char *
1245 find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1246 {
1247   char *base;
1248   char *dir;
1249   char *debugfile;
1250   char *canon_dir;
1251   unsigned long crc32;
1252   size_t dirlen;
1253   size_t canon_dirlen;
1254
1255   BFD_ASSERT (abfd);
1256   if (debug_file_directory == NULL)
1257     debug_file_directory = ".";
1258
1259   /* BFD may have been opened from a stream.  */
1260   if (abfd->filename == NULL)
1261     {
1262       bfd_set_error (bfd_error_invalid_operation);
1263       return NULL;
1264     }
1265
1266   base = bfd_get_debug_link_info (abfd, & crc32);
1267   if (base == NULL)
1268     return NULL;
1269
1270   if (base[0] == '\0')
1271     {
1272       free (base);
1273       bfd_set_error (bfd_error_no_debug_section);
1274       return NULL;
1275     }
1276
1277   for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--)
1278     if (IS_DIR_SEPARATOR (abfd->filename[dirlen - 1]))
1279       break;
1280
1281   dir = (char *) bfd_malloc (dirlen + 1);
1282   if (dir == NULL)
1283     {
1284       free (base);
1285       return NULL;
1286     }
1287   memcpy (dir, abfd->filename, dirlen);
1288   dir[dirlen] = '\0';
1289
1290   /* Compute the canonical name of the bfd object with all symbolic links
1291      resolved, for use in the global debugfile directory.  */
1292   canon_dir = lrealpath (abfd->filename);
1293   for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1294     if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1295       break;
1296   canon_dir[canon_dirlen] = '\0';
1297
1298   debugfile = (char *)
1299       bfd_malloc (strlen (debug_file_directory) + 1
1300                   + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1301                   + strlen (".debug/")
1302                   + strlen (base)
1303                   + 1);
1304   if (debugfile == NULL)
1305     {
1306       free (base);
1307       free (dir);
1308       free (canon_dir);
1309       return NULL;
1310     }
1311
1312   /* First try in the same directory as the original file:  */
1313   strcpy (debugfile, dir);
1314   strcat (debugfile, base);
1315
1316   if (separate_debug_file_exists (debugfile, crc32))
1317     {
1318       free (base);
1319       free (dir);
1320       free (canon_dir);
1321       return debugfile;
1322     }
1323
1324   /* Then try in a subdirectory called .debug.  */
1325   strcpy (debugfile, dir);
1326   strcat (debugfile, ".debug/");
1327   strcat (debugfile, base);
1328
1329   if (separate_debug_file_exists (debugfile, crc32))
1330     {
1331       free (base);
1332       free (dir);
1333       free (canon_dir);
1334       return debugfile;
1335     }
1336
1337   /* Then try in the global debugfile directory.  */
1338   strcpy (debugfile, debug_file_directory);
1339   dirlen = strlen (debug_file_directory) - 1;
1340   if (dirlen > 0
1341       && debug_file_directory[dirlen] != '/'
1342       && canon_dir[0] != '/')
1343     strcat (debugfile, "/");
1344   strcat (debugfile, canon_dir);
1345   strcat (debugfile, base);
1346
1347   if (separate_debug_file_exists (debugfile, crc32))
1348     {
1349       free (base);
1350       free (dir);
1351       free (canon_dir);
1352       return debugfile;
1353     }
1354
1355   free (debugfile);
1356   free (base);
1357   free (dir);
1358   free (canon_dir);
1359   return NULL;
1360 }
1361
1362
1363 /*
1364 FUNCTION
1365         bfd_follow_gnu_debuglink
1366
1367 SYNOPSIS
1368         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1369
1370 DESCRIPTION
1371
1372         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1373         section is found, it examines the section for the name and checksum
1374         of a '.debug' file containing auxiliary debugging information.  It
1375         then searches the filesystem for this .debug file in some standard
1376         locations, including the directory tree rooted at @var{dir}, and if
1377         found returns the full filename.
1378
1379         If @var{dir} is NULL, it will search a default path configured into
1380         libbfd at build time.  [XXX this feature is not currently
1381         implemented].
1382
1383 RETURNS
1384         <<NULL>> on any errors or failure to locate the .debug file,
1385         otherwise a pointer to a heap-allocated string containing the
1386         filename.  The caller is responsible for freeing this string.
1387 */
1388
1389 char *
1390 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1391 {
1392   return find_separate_debug_file (abfd, dir);
1393 }
1394
1395 /*
1396 FUNCTION
1397         bfd_create_gnu_debuglink_section
1398
1399 SYNOPSIS
1400         struct bfd_section *bfd_create_gnu_debuglink_section
1401           (bfd *abfd, const char *filename);
1402
1403 DESCRIPTION
1404
1405         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The section is sized
1406         to be big enough to contain a link to the specified @var{filename}.
1407
1408 RETURNS
1409         A pointer to the new section is returned if all is ok.  Otherwise <<NULL>> is
1410         returned and bfd_error is set.
1411 */
1412
1413 asection *
1414 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1415 {
1416   asection *sect;
1417   bfd_size_type debuglink_size;
1418   flagword flags;
1419
1420   if (abfd == NULL || filename == NULL)
1421     {
1422       bfd_set_error (bfd_error_invalid_operation);
1423       return NULL;
1424     }
1425
1426   /* Strip off any path components in filename.  */
1427   filename = lbasename (filename);
1428
1429   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1430   if (sect)
1431     {
1432       /* Section already exists.  */
1433       bfd_set_error (bfd_error_invalid_operation);
1434       return NULL;
1435     }
1436
1437   flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1438   sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1439   if (sect == NULL)
1440     return NULL;
1441
1442   debuglink_size = strlen (filename) + 1;
1443   debuglink_size += 3;
1444   debuglink_size &= ~3;
1445   debuglink_size += 4;
1446
1447   if (! bfd_set_section_size (abfd, sect, debuglink_size))
1448     /* XXX Should we delete the section from the bfd ?  */
1449     return NULL;
1450
1451   return sect;
1452 }
1453
1454
1455 /*
1456 FUNCTION
1457         bfd_fill_in_gnu_debuglink_section
1458
1459 SYNOPSIS
1460         bfd_boolean bfd_fill_in_gnu_debuglink_section
1461           (bfd *abfd, struct bfd_section *sect, const char *filename);
1462
1463 DESCRIPTION
1464
1465         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1466         and fills in the contents of the section to contain a link to the
1467         specified @var{filename}.  The filename should be relative to the
1468         current directory.
1469
1470 RETURNS
1471         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1472         and bfd_error is set.
1473 */
1474
1475 bfd_boolean
1476 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1477                                    struct bfd_section *sect,
1478                                    const char *filename)
1479 {
1480   bfd_size_type debuglink_size;
1481   unsigned long crc32;
1482   char * contents;
1483   bfd_size_type crc_offset;
1484   FILE * handle;
1485   static unsigned char buffer[8 * 1024];
1486   size_t count;
1487   size_t filelen;
1488
1489   if (abfd == NULL || sect == NULL || filename == NULL)
1490     {
1491       bfd_set_error (bfd_error_invalid_operation);
1492       return FALSE;
1493     }
1494
1495   /* Make sure that we can read the file.
1496      XXX - Should we attempt to locate the debug info file using the same
1497      algorithm as gdb ?  At the moment, since we are creating the
1498      .gnu_debuglink section, we insist upon the user providing us with a
1499      correct-for-section-creation-time path, but this need not conform to
1500      the gdb location algorithm.  */
1501   handle = real_fopen (filename, FOPEN_RB);
1502   if (handle == NULL)
1503     {
1504       bfd_set_error (bfd_error_system_call);
1505       return FALSE;
1506     }
1507
1508   crc32 = 0;
1509   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1510     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1511   fclose (handle);
1512
1513   /* Strip off any path components in filename,
1514      now that we no longer need them.  */
1515   filename = lbasename (filename);
1516
1517   filelen = strlen (filename);
1518   debuglink_size = filelen + 1;
1519   debuglink_size += 3;
1520   debuglink_size &= ~3;
1521   debuglink_size += 4;
1522
1523   contents = (char *) bfd_malloc (debuglink_size);
1524   if (contents == NULL)
1525     {
1526       /* XXX Should we delete the section from the bfd ?  */
1527       return FALSE;
1528     }
1529
1530   crc_offset = debuglink_size - 4;
1531   memcpy (contents, filename, filelen);
1532   memset (contents + filelen, 0, crc_offset - filelen);
1533
1534   bfd_put_32 (abfd, crc32, contents + crc_offset);
1535
1536   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1537     {
1538       /* XXX Should we delete the section from the bfd ?  */
1539       free (contents);
1540       return FALSE;
1541     }
1542
1543   return TRUE;
1544 }