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