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   /* `open (...)' would get expanded by an the open(2) syscall macro.  */
 549   stream = (*open) (nbfd, open_closure);
 550   if (stream == NULL)
 551     {
 552       _bfd_delete_bfd (nbfd);
 553       return NULL;
 554     }
 555
 556   vec = bfd_zalloc (nbfd, sizeof (struct opncls));
 557   vec->stream = stream;
 558   vec->pread = pread;
 559   vec->close = close;
 560   vec->stat = stat;
 561
 562   nbfd->iovec = &opncls_iovec;
 563   nbfd->iostream = vec;
 564
 565   return nbfd;
 566 }
 567 \f
 568 /* bfd_openw -- open for writing.
 569    Returns a pointer to a freshly-allocated BFD on success, or NULL.
 570
 571    See comment by bfd_fdopenr before you try to modify this function.  */
 572
 573 /*
 574 FUNCTION
 575         bfd_openw
 576
 577 SYNOPSIS
 578         bfd *bfd_openw (const char *filename, const char *target);
 579
 580 DESCRIPTION
 581         Create a BFD, associated with file @var{filename}, using the
 582         file format @var{target}, and return a pointer to it.
 583
 584         Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
 585         <<bfd_error_invalid_target>>.
 586 */
 587
 588 bfd *
 589 bfd_openw (const char *filename, const char *target)
 590 {
 591   bfd *nbfd;
 592   const bfd_target *target_vec;
 593
 594   /* nbfd has to point to head of malloc'ed block so that bfd_close may
 595      reclaim it correctly.  */
 596   nbfd = _bfd_new_bfd ();
 597   if (nbfd == NULL)
 598     return NULL;
 599
 600   target_vec = bfd_find_target (target, nbfd);
 601   if (target_vec == NULL)
 602     {
 603       _bfd_delete_bfd (nbfd);
 604       return NULL;
 605     }
 606
 607   nbfd->filename = filename;
 608   nbfd->direction = write_direction;
 609
 610   if (bfd_open_file (nbfd) == NULL)
 611     {
 612       /* File not writeable, etc.  */
 613       bfd_set_error (bfd_error_system_call);
 614       _bfd_delete_bfd (nbfd);
 615       return NULL;
 616   }
 617
 618   return nbfd;
 619 }
 620
 621 /*
 622
 623 FUNCTION
 624         bfd_close
 625
 626 SYNOPSIS
 627         bfd_boolean bfd_close (bfd *abfd);
 628
 629 DESCRIPTION
 630
 631         Close a BFD. If the BFD was open for writing, then pending
 632         operations are completed and the file written out and closed.
 633         If the created file is executable, then <<chmod>> is called
 634         to mark it as such.
 635
 636         All memory attached to the BFD is released.
 637
 638         The file descriptor associated with the BFD is closed (even
 639         if it was passed in to BFD by <<bfd_fdopenr>>).
 640
 641 RETURNS
 642         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 643 */
 644
 645
 646 bfd_boolean
 647 bfd_close (bfd *abfd)
 648 {
 649   bfd_boolean ret;
 650
 651   if (bfd_write_p (abfd))
 652     {
 653       if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 654         return FALSE;
 655     }
 656
 657   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 658     return FALSE;
 659
 660   /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io
 661      vector.  */
 662   if (!(abfd->flags & BFD_IN_MEMORY))
 663     ret = abfd->iovec->bclose (abfd);
 664   else
 665     ret = TRUE;
 666
 667   /* If the file was open for writing and is now executable,
 668      make it so.  */
 669   if (ret
 670       && abfd->direction == write_direction
 671       && abfd->flags & EXEC_P)
 672     {
 673       struct stat buf;
 674
 675       if (stat (abfd->filename, &buf) == 0)
 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   _bfd_delete_bfd (abfd);
 687
 688   return ret;
 689 }
 690
 691 /*
 692 FUNCTION
 693         bfd_close_all_done
 694
 695 SYNOPSIS
 696         bfd_boolean bfd_close_all_done (bfd *);
 697
 698 DESCRIPTION
 699         Close a BFD.  Differs from <<bfd_close>> since it does not
 700         complete any pending operations.  This routine would be used
 701         if the application had just used BFD for swapping and didn't
 702         want to use any of the writing code.
 703
 704         If the created file is executable, then <<chmod>> is called
 705         to mark it as such.
 706
 707         All memory attached to the BFD is released.
 708
 709 RETURNS
 710         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 711 */
 712
 713 bfd_boolean
 714 bfd_close_all_done (bfd *abfd)
 715 {
 716   bfd_boolean ret;
 717
 718   ret = bfd_cache_close (abfd);
 719
 720   /* If the file was open for writing and is now executable,
 721      make it so.  */
 722   if (ret
 723       && abfd->direction == write_direction
 724       && abfd->flags & EXEC_P)
 725     {
 726       struct stat buf;
 727
 728       if (stat (abfd->filename, &buf) == 0)
 729         {
 730           unsigned int mask = umask (0);
 731
 732           umask (mask);
 733           chmod (abfd->filename,
 734                  (0777
 735                   & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
 736         }
 737     }
 738
 739   _bfd_delete_bfd (abfd);
 740
 741   return ret;
 742 }
 743
 744 /*
 745 FUNCTION
 746         bfd_create
 747
 748 SYNOPSIS
 749         bfd *bfd_create (const char *filename, bfd *templ);
 750
 751 DESCRIPTION
 752         Create a new BFD in the manner of <<bfd_openw>>, but without
 753         opening a file. The new BFD takes the target from the target
 754         used by @var{template}. The format is always set to <<bfd_object>>.
 755 */
 756
 757 bfd *
 758 bfd_create (const char *filename, bfd *templ)
 759 {
 760   bfd *nbfd;
 761
 762   nbfd = _bfd_new_bfd ();
 763   if (nbfd == NULL)
 764     return NULL;
 765   nbfd->filename = filename;
 766   if (templ)
 767     nbfd->xvec = templ->xvec;
 768   nbfd->direction = no_direction;
 769   bfd_set_format (nbfd, bfd_object);
 770
 771   return nbfd;
 772 }
 773
 774 /*
 775 FUNCTION
 776         bfd_make_writable
 777
 778 SYNOPSIS
 779         bfd_boolean bfd_make_writable (bfd *abfd);
 780
 781 DESCRIPTION
 782         Takes a BFD as created by <<bfd_create>> and converts it
 783         into one like as returned by <<bfd_openw>>.  It does this
 784         by converting the BFD to BFD_IN_MEMORY.  It's assumed that
 785         you will call <<bfd_make_readable>> on this bfd later.
 786
 787 RETURNS
 788         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 789 */
 790
 791 bfd_boolean
 792 bfd_make_writable (bfd *abfd)
 793 {
 794   struct bfd_in_memory *bim;
 795
 796   if (abfd->direction != no_direction)
 797     {
 798       bfd_set_error (bfd_error_invalid_operation);
 799       return FALSE;
 800     }
 801
 802   bim = bfd_malloc (sizeof (struct bfd_in_memory));
 803   if (bim == NULL)
 804     return FALSE;       /* bfd_error already set.  */
 805   abfd->iostream = bim;
 806   /* bfd_bwrite will grow these as needed.  */
 807   bim->size = 0;
 808   bim->buffer = 0;
 809
 810   abfd->flags |= BFD_IN_MEMORY;
 811   abfd->direction = write_direction;
 812   abfd->where = 0;
 813
 814   return TRUE;
 815 }
 816
 817 /*
 818 FUNCTION
 819         bfd_make_readable
 820
 821 SYNOPSIS
 822         bfd_boolean bfd_make_readable (bfd *abfd);
 823
 824 DESCRIPTION
 825         Takes a BFD as created by <<bfd_create>> and
 826         <<bfd_make_writable>> and converts it into one like as
 827         returned by <<bfd_openr>>.  It does this by writing the
 828         contents out to the memory buffer, then reversing the
 829         direction.
 830
 831 RETURNS
 832         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
 833
 834 bfd_boolean
 835 bfd_make_readable (bfd *abfd)
 836 {
 837   if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
 838     {
 839       bfd_set_error (bfd_error_invalid_operation);
 840       return FALSE;
 841     }
 842
 843   if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 844     return FALSE;
 845
 846   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 847     return FALSE;
 848
 849
 850   abfd->arch_info = &bfd_default_arch_struct;
 851
 852   abfd->where = 0;
 853   abfd->format = bfd_unknown;
 854   abfd->my_archive = NULL;
 855   abfd->origin = 0;
 856   abfd->opened_once = FALSE;
 857   abfd->output_has_begun = FALSE;
 858   abfd->section_count = 0;
 859   abfd->usrdata = NULL;
 860   abfd->cacheable = FALSE;
 861   abfd->flags = BFD_IN_MEMORY;
 862   abfd->mtime_set = FALSE;
 863
 864   abfd->target_defaulted = TRUE;
 865   abfd->direction = read_direction;
 866   abfd->sections = 0;
 867   abfd->symcount = 0;
 868   abfd->outsymbols = 0;
 869   abfd->tdata.any = 0;
 870
 871   bfd_section_list_clear (abfd);
 872   bfd_check_format (abfd, bfd_object);
 873
 874   return TRUE;
 875 }
 876
 877 /*
 878 INTERNAL_FUNCTION
 879         bfd_alloc
 880
 881 SYNOPSIS
 882         void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
 883
 884 DESCRIPTION
 885         Allocate a block of @var{wanted} bytes of memory attached to
 886         <<abfd>> and return a pointer to it.
 887 */
 888
 889 void *
 890 bfd_alloc (bfd *abfd, bfd_size_type size)
 891 {
 892   void *ret;
 893
 894   if (size != (unsigned long) size)
 895     {
 896       bfd_set_error (bfd_error_no_memory);
 897       return NULL;
 898     }
 899
 900   ret = objalloc_alloc (abfd->memory, (unsigned long) size);
 901   if (ret == NULL)
 902     bfd_set_error (bfd_error_no_memory);
 903   return ret;
 904 }
 905
 906 /*
 907 INTERNAL_FUNCTION
 908         bfd_alloc2
 909
 910 SYNOPSIS
 911         void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
 912
 913 DESCRIPTION
 914         Allocate a block of @var{nmemb} elements of @var{size} bytes each
 915         of memory attached to <<abfd>> and return a pointer to it.
 916 */
 917
 918 void *
 919 bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
 920 {
 921   void *ret;
 922
 923   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
 924       && size != 0
 925       && nmemb > ~(bfd_size_type) 0 / size)
 926     {
 927       bfd_set_error (bfd_error_no_memory);
 928       return NULL;
 929     }
 930
 931   size *= nmemb;
 932
 933   if (size != (unsigned long) size)
 934     {
 935       bfd_set_error (bfd_error_no_memory);
 936       return NULL;
 937     }
 938
 939   ret = objalloc_alloc (abfd->memory, (unsigned long) size);
 940   if (ret == NULL)
 941     bfd_set_error (bfd_error_no_memory);
 942   return ret;
 943 }
 944
 945 /*
 946 INTERNAL_FUNCTION
 947         bfd_zalloc
 948
 949 SYNOPSIS
 950         void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
 951
 952 DESCRIPTION
 953         Allocate a block of @var{wanted} bytes of zeroed memory
 954         attached to <<abfd>> and return a pointer to it.
 955 */
 956
 957 void *
 958 bfd_zalloc (bfd *abfd, bfd_size_type size)
 959 {
 960   void *res;
 961
 962   res = bfd_alloc (abfd, size);
 963   if (res)
 964     memset (res, 0, (size_t) size);
 965   return res;
 966 }
 967
 968 /*
 969 INTERNAL_FUNCTION
 970         bfd_zalloc2
 971
 972 SYNOPSIS
 973         void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
 974
 975 DESCRIPTION
 976         Allocate a block of @var{nmemb} elements of @var{size} bytes each
 977         of zeroed memory attached to <<abfd>> and return a pointer to it.
 978 */
 979
 980 void *
 981 bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
 982 {
 983   void *res;
 984
 985   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
 986       && size != 0
 987       && nmemb > ~(bfd_size_type) 0 / size)
 988     {
 989       bfd_set_error (bfd_error_no_memory);
 990       return NULL;
 991     }
 992
 993   size *= nmemb;
 994
 995   res = bfd_alloc (abfd, size);
 996   if (res)
 997     memset (res, 0, (size_t) size);
 998   return res;
 999 }
1000
1001 /* Free a block allocated for a BFD.
1002    Note:  Also frees all more recently allocated blocks!  */
1003
1004 void
1005 bfd_release (bfd *abfd, void *block)
1006 {
1007   objalloc_free_block ((struct objalloc *) abfd->memory, block);
1008 }
1009
1010
1011 /*
1012    GNU Extension: separate debug-info files
1013
1014    The idea here is that a special section called .gnu_debuglink might be
1015    embedded in a binary file, which indicates that some *other* file
1016    contains the real debugging information. This special section contains a
1017    filename and CRC32 checksum, which we read and resolve to another file,
1018    if it exists.
1019
1020    This facilitates "optional" provision of debugging information, without
1021    having to provide two complete copies of every binary object (with and
1022    without debug symbols).
1023 */
1024
1025 #define GNU_DEBUGLINK   ".gnu_debuglink"
1026 /*
1027 FUNCTION
1028         bfd_calc_gnu_debuglink_crc32
1029
1030 SYNOPSIS
1031         unsigned long bfd_calc_gnu_debuglink_crc32
1032           (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1033
1034 DESCRIPTION
1035         Computes a CRC value as used in the .gnu_debuglink section.
1036         Advances the previously computed @var{crc} value by computing
1037         and adding in the crc32 for @var{len} bytes of @var{buf}.
1038
1039 RETURNS
1040         Return the updated CRC32 value.
1041 */
1042
1043 unsigned long
1044 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1045                               const unsigned char *buf,
1046                               bfd_size_type len)
1047 {
1048   static const unsigned long crc32_table[256] =
1049     {
1050       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1051       0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1052       0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1053       0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1054       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1055       0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1056       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1057       0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1058       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1059       0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1060       0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1061       0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1062       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1063       0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1064       0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1065       0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1066       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1067       0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1068       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1069       0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1070       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1071       0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1072       0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1073       0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1074       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1075       0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1076       0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1077       0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1078       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1079       0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1080       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1081       0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1082       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1083       0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1084       0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1085       0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1086       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1087       0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1088       0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1089       0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1090       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1091       0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1092       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1093       0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1094       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1095       0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1096       0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1097       0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1098       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1099       0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1100       0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1101       0x2d02ef8d
1102     };
1103   const unsigned char *end;
1104
1105   crc = ~crc & 0xffffffff;
1106   for (end = buf + len; buf < end; ++ buf)
1107     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1108   return ~crc & 0xffffffff;;
1109 }
1110
1111
1112 /*
1113 INTERNAL_FUNCTION
1114         get_debug_link_info
1115
1116 SYNOPSIS
1117         char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1118
1119 DESCRIPTION
1120         fetch the filename and CRC32 value for any separate debuginfo
1121         associated with @var{abfd}. Return NULL if no such info found,
1122         otherwise return filename and update @var{crc32_out}.
1123 */
1124
1125 static char *
1126 get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1127 {
1128   asection *sect;
1129   unsigned long crc32;
1130   bfd_byte *contents;
1131   int crc_offset;
1132   char *name;
1133
1134   BFD_ASSERT (abfd);
1135   BFD_ASSERT (crc32_out);
1136
1137   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1138
1139   if (sect == NULL)
1140     return NULL;
1141
1142   if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1143     {
1144       if (contents != NULL)
1145         free (contents);
1146       return NULL;
1147     }
1148
1149   /* Crc value is stored after the filename, aligned up to 4 bytes.  */
1150   name = (char *) contents;
1151   crc_offset = strlen (name) + 1;
1152   crc_offset = (crc_offset + 3) & ~3;
1153
1154   crc32 = bfd_get_32 (abfd, contents + crc_offset);
1155
1156   *crc32_out = crc32;
1157   return name;
1158 }
1159
1160 /*
1161 INTERNAL_FUNCTION
1162         separate_debug_file_exists
1163
1164 SYNOPSIS
1165         bfd_boolean separate_debug_file_exists
1166           (char *name, unsigned long crc32);
1167
1168 DESCRIPTION
1169         Checks to see if @var{name} is a file and if its contents
1170         match @var{crc32}.
1171 */
1172
1173 static bfd_boolean
1174 separate_debug_file_exists (const char *name, const unsigned long crc)
1175 {
1176   static unsigned char buffer [8 * 1024];
1177   unsigned long file_crc = 0;
1178   int fd;
1179   bfd_size_type count;
1180
1181   BFD_ASSERT (name);
1182
1183   fd = open (name, O_RDONLY);
1184   if (fd < 0)
1185     return FALSE;
1186
1187   while ((count = read (fd, buffer, sizeof (buffer))) > 0)
1188     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1189
1190   close (fd);
1191
1192   return crc == file_crc;
1193 }
1194
1195
1196 /*
1197 INTERNAL_FUNCTION
1198         find_separate_debug_file
1199
1200 SYNOPSIS
1201         char *find_separate_debug_file (bfd *abfd);
1202
1203 DESCRIPTION
1204         Searches @var{abfd} for a reference to separate debugging
1205         information, scans various locations in the filesystem, including
1206         the file tree rooted at @var{debug_file_directory}, and returns a
1207         filename of such debugging information if the file is found and has
1208         matching CRC32.  Returns NULL if no reference to debugging file
1209         exists, or file cannot be found.
1210 */
1211
1212 static char *
1213 find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1214 {
1215   char *basename;
1216   char *dir;
1217   char *debugfile;
1218   unsigned long crc32;
1219   int i;
1220
1221   BFD_ASSERT (abfd);
1222   if (debug_file_directory == NULL)
1223     debug_file_directory = ".";
1224
1225   /* BFD may have been opened from a stream.  */
1226   if (! abfd->filename)
1227     return NULL;
1228
1229   basename = get_debug_link_info (abfd, & crc32);
1230   if (basename == NULL)
1231     return NULL;
1232
1233   if (strlen (basename) < 1)
1234     {
1235       free (basename);
1236       return NULL;
1237     }
1238
1239   dir = strdup (abfd->filename);
1240   if (dir == NULL)
1241     {
1242       free (basename);
1243       return NULL;
1244     }
1245   BFD_ASSERT (strlen (dir) != 0);
1246
1247   /* Strip off filename part.  */
1248   for (i = strlen (dir) - 1; i >= 0; i--)
1249     if (IS_DIR_SEPARATOR (dir[i]))
1250       break;
1251
1252   dir[i + 1] = '\0';
1253   BFD_ASSERT (dir[i] == '/' || dir[0] == '\0');
1254
1255   debugfile = malloc (strlen (debug_file_directory) + 1
1256                       + strlen (dir)
1257                       + strlen (".debug/")
1258                       + strlen (basename)
1259                       + 1);
1260   if (debugfile == NULL)
1261     {
1262       free (basename);
1263       free (dir);
1264       return NULL;
1265     }
1266
1267   /* First try in the same directory as the original file:  */
1268   strcpy (debugfile, dir);
1269   strcat (debugfile, basename);
1270
1271   if (separate_debug_file_exists (debugfile, crc32))
1272     {
1273       free (basename);
1274       free (dir);
1275       return debugfile;
1276     }
1277
1278   /* Then try in a subdirectory called .debug.  */
1279   strcpy (debugfile, dir);
1280   strcat (debugfile, ".debug/");
1281   strcat (debugfile, basename);
1282
1283   if (separate_debug_file_exists (debugfile, crc32))
1284     {
1285       free (basename);
1286       free (dir);
1287       return debugfile;
1288     }
1289
1290   /* Then try in the global debugfile directory.  */
1291   strcpy (debugfile, debug_file_directory);
1292   i = strlen (debug_file_directory) - 1;
1293   if (i > 0
1294       && debug_file_directory[i] != '/'
1295       && dir[0] != '/')
1296     strcat (debugfile, "/");
1297   strcat (debugfile, dir);
1298   strcat (debugfile, basename);
1299
1300   if (separate_debug_file_exists (debugfile, crc32))
1301     {
1302       free (basename);
1303       free (dir);
1304       return debugfile;
1305     }
1306
1307   free (debugfile);
1308   free (basename);
1309   free (dir);
1310   return NULL;
1311 }
1312
1313
1314 /*
1315 FUNCTION
1316         bfd_follow_gnu_debuglink
1317
1318 SYNOPSIS
1319         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1320
1321 DESCRIPTION
1322
1323         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1324         section is found, it examines the section for the name and checksum
1325         of a '.debug' file containing auxiliary debugging information.  It
1326         then searches the filesystem for this .debug file in some standard
1327         locations, including the directory tree rooted at @var{dir}, and if
1328         found returns the full filename.
1329
1330         If @var{dir} is NULL, it will search a default path configured into
1331         libbfd at build time.  [XXX this feature is not currently
1332         implemented].
1333
1334 RETURNS
1335         <<NULL>> on any errors or failure to locate the .debug file,
1336         otherwise a pointer to a heap-allocated string containing the
1337         filename.  The caller is responsible for freeing this string.
1338 */
1339
1340 char *
1341 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1342 {
1343   return find_separate_debug_file (abfd, dir);
1344 }
1345
1346 /*
1347 FUNCTION
1348         bfd_create_gnu_debuglink_section
1349
1350 SYNOPSIS
1351         struct bfd_section *bfd_create_gnu_debuglink_section
1352           (bfd *abfd, const char *filename);
1353
1354 DESCRIPTION
1355
1356         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The section is sized
1357         to be big enough to contain a link to the specified @var{filename}.
1358
1359 RETURNS
1360         A pointer to the new section is returned if all is ok.  Otherwise <<NULL>> is
1361         returned and bfd_error is set.
1362 */
1363
1364 asection *
1365 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1366 {
1367   asection *sect;
1368   bfd_size_type debuglink_size;
1369   flagword flags;
1370
1371   if (abfd == NULL || filename == NULL)
1372     {
1373       bfd_set_error (bfd_error_invalid_operation);
1374       return NULL;
1375     }
1376
1377   /* Strip off any path components in filename.  */
1378   filename = lbasename (filename);
1379
1380   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1381   if (sect)
1382     {
1383       /* Section already exists.  */
1384       bfd_set_error (bfd_error_invalid_operation);
1385       return NULL;
1386     }
1387
1388   flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1389   sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1390   if (sect == NULL)
1391     return NULL;
1392
1393   debuglink_size = strlen (filename) + 1;
1394   debuglink_size += 3;
1395   debuglink_size &= ~3;
1396   debuglink_size += 4;
1397
1398   if (! bfd_set_section_size (abfd, sect, debuglink_size))
1399     /* XXX Should we delete the section from the bfd ?  */
1400     return NULL;
1401
1402   return sect;
1403 }
1404
1405
1406 /*
1407 FUNCTION
1408         bfd_fill_in_gnu_debuglink_section
1409
1410 SYNOPSIS
1411         bfd_boolean bfd_fill_in_gnu_debuglink_section
1412           (bfd *abfd, struct bfd_section *sect, const char *filename);
1413
1414 DESCRIPTION
1415
1416         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1417         and fills in the contents of the section to contain a link to the
1418         specified @var{filename}.  The filename should be relative to the
1419         current directory.
1420
1421 RETURNS
1422         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1423         and bfd_error is set.
1424 */
1425
1426 bfd_boolean
1427 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1428                                    struct bfd_section *sect,
1429                                    const char *filename)
1430 {
1431   bfd_size_type debuglink_size;
1432   unsigned long crc32;
1433   char * contents;
1434   bfd_size_type crc_offset;
1435   FILE * handle;
1436   static unsigned char buffer[8 * 1024];
1437   size_t count;
1438
1439   if (abfd == NULL || sect == NULL || filename == NULL)
1440     {
1441       bfd_set_error (bfd_error_invalid_operation);
1442       return FALSE;
1443     }
1444
1445   /* Make sure that we can read the file.
1446      XXX - Should we attempt to locate the debug info file using the same
1447      algorithm as gdb ?  At the moment, since we are creating the
1448      .gnu_debuglink section, we insist upon the user providing us with a
1449      correct-for-section-creation-time path, but this need not conform to
1450      the gdb location algorithm.  */
1451   handle = real_fopen (filename, FOPEN_RB);
1452   if (handle == NULL)
1453     {
1454       bfd_set_error (bfd_error_system_call);
1455       return FALSE;
1456     }
1457
1458   crc32 = 0;
1459   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1460     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1461   fclose (handle);
1462
1463   /* Strip off any path components in filename,
1464      now that we no longer need them.  */
1465   filename = lbasename (filename);
1466
1467   debuglink_size = strlen (filename) + 1;
1468   debuglink_size += 3;
1469   debuglink_size &= ~3;
1470   debuglink_size += 4;
1471
1472   contents = malloc (debuglink_size);
1473   if (contents == NULL)
1474     {
1475       /* XXX Should we delete the section from the bfd ?  */
1476       bfd_set_error (bfd_error_no_memory);
1477       return FALSE;
1478     }
1479
1480   strcpy (contents, filename);
1481   crc_offset = debuglink_size - 4;
1482
1483   bfd_put_32 (abfd, crc32, contents + crc_offset);
1484
1485   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1486     {
1487       /* XXX Should we delete the section from the bfd ?  */
1488       free (contents);
1489       return FALSE;
1490     }
1491
1492   return TRUE;
1493 }