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   abfd->iostream = bim;
 803   /* bfd_bwrite will grow these as needed.  */
 804   bim->size = 0;
 805   bim->buffer = 0;
 806
 807   abfd->flags |= BFD_IN_MEMORY;
 808   abfd->direction = write_direction;
 809   abfd->where = 0;
 810
 811   return TRUE;
 812 }
 813
 814 /*
 815 FUNCTION
 816         bfd_make_readable
 817
 818 SYNOPSIS
 819         bfd_boolean bfd_make_readable (bfd *abfd);
 820
 821 DESCRIPTION
 822         Takes a BFD as created by <<bfd_create>> and
 823         <<bfd_make_writable>> and converts it into one like as
 824         returned by <<bfd_openr>>.  It does this by writing the
 825         contents out to the memory buffer, then reversing the
 826         direction.
 827
 828 RETURNS
 829         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
 830
 831 bfd_boolean
 832 bfd_make_readable (bfd *abfd)
 833 {
 834   if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
 835     {
 836       bfd_set_error (bfd_error_invalid_operation);
 837       return FALSE;
 838     }
 839
 840   if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 841     return FALSE;
 842
 843   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 844     return FALSE;
 845
 846
 847   abfd->arch_info = &bfd_default_arch_struct;
 848
 849   abfd->where = 0;
 850   abfd->format = bfd_unknown;
 851   abfd->my_archive = NULL;
 852   abfd->origin = 0;
 853   abfd->opened_once = FALSE;
 854   abfd->output_has_begun = FALSE;
 855   abfd->section_count = 0;
 856   abfd->usrdata = NULL;
 857   abfd->cacheable = FALSE;
 858   abfd->flags = BFD_IN_MEMORY;
 859   abfd->mtime_set = FALSE;
 860
 861   abfd->target_defaulted = TRUE;
 862   abfd->direction = read_direction;
 863   abfd->sections = 0;
 864   abfd->symcount = 0;
 865   abfd->outsymbols = 0;
 866   abfd->tdata.any = 0;
 867
 868   bfd_section_list_clear (abfd);
 869   bfd_check_format (abfd, bfd_object);
 870
 871   return TRUE;
 872 }
 873
 874 /*
 875 INTERNAL_FUNCTION
 876         bfd_alloc
 877
 878 SYNOPSIS
 879         void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
 880
 881 DESCRIPTION
 882         Allocate a block of @var{wanted} bytes of memory attached to
 883         <<abfd>> and return a pointer to it.
 884 */
 885
 886 void *
 887 bfd_alloc (bfd *abfd, bfd_size_type size)
 888 {
 889   void *ret;
 890
 891   if (size != (unsigned long) size)
 892     {
 893       bfd_set_error (bfd_error_no_memory);
 894       return NULL;
 895     }
 896
 897   ret = objalloc_alloc (abfd->memory, (unsigned long) size);
 898   if (ret == NULL)
 899     bfd_set_error (bfd_error_no_memory);
 900   return ret;
 901 }
 902
 903 /*
 904 INTERNAL_FUNCTION
 905         bfd_alloc2
 906
 907 SYNOPSIS
 908         void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
 909
 910 DESCRIPTION
 911         Allocate a block of @var{nmemb} elements of @var{size} bytes each
 912         of memory attached to <<abfd>> and return a pointer to it.
 913 */
 914
 915 void *
 916 bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
 917 {
 918   void *ret;
 919
 920   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
 921       && size != 0
 922       && nmemb > ~(bfd_size_type) 0 / size)
 923     {
 924       bfd_set_error (bfd_error_no_memory);
 925       return NULL;
 926     }
 927
 928   size *= nmemb;
 929
 930   if (size != (unsigned long) size)
 931     {
 932       bfd_set_error (bfd_error_no_memory);
 933       return NULL;
 934     }
 935
 936   ret = objalloc_alloc (abfd->memory, (unsigned long) size);
 937   if (ret == NULL)
 938     bfd_set_error (bfd_error_no_memory);
 939   return ret;
 940 }
 941
 942 /*
 943 INTERNAL_FUNCTION
 944         bfd_zalloc
 945
 946 SYNOPSIS
 947         void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
 948
 949 DESCRIPTION
 950         Allocate a block of @var{wanted} bytes of zeroed memory
 951         attached to <<abfd>> and return a pointer to it.
 952 */
 953
 954 void *
 955 bfd_zalloc (bfd *abfd, bfd_size_type size)
 956 {
 957   void *res;
 958
 959   res = bfd_alloc (abfd, size);
 960   if (res)
 961     memset (res, 0, (size_t) size);
 962   return res;
 963 }
 964
 965 /*
 966 INTERNAL_FUNCTION
 967         bfd_zalloc2
 968
 969 SYNOPSIS
 970         void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
 971
 972 DESCRIPTION
 973         Allocate a block of @var{nmemb} elements of @var{size} bytes each
 974         of zeroed memory attached to <<abfd>> and return a pointer to it.
 975 */
 976
 977 void *
 978 bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
 979 {
 980   void *res;
 981
 982   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
 983       && size != 0
 984       && nmemb > ~(bfd_size_type) 0 / size)
 985     {
 986       bfd_set_error (bfd_error_no_memory);
 987       return NULL;
 988     }
 989
 990   size *= nmemb;
 991
 992   res = bfd_alloc (abfd, size);
 993   if (res)
 994     memset (res, 0, (size_t) size);
 995   return res;
 996 }
 997
 998 /* Free a block allocated for a BFD.
 999    Note:  Also frees all more recently allocated blocks!  */
1000
1001 void
1002 bfd_release (bfd *abfd, void *block)
1003 {
1004   objalloc_free_block ((struct objalloc *) abfd->memory, block);
1005 }
1006
1007
1008 /*
1009    GNU Extension: separate debug-info files
1010
1011    The idea here is that a special section called .gnu_debuglink might be
1012    embedded in a binary file, which indicates that some *other* file
1013    contains the real debugging information. This special section contains a
1014    filename and CRC32 checksum, which we read and resolve to another file,
1015    if it exists.
1016
1017    This facilitates "optional" provision of debugging information, without
1018    having to provide two complete copies of every binary object (with and
1019    without debug symbols).
1020 */
1021
1022 #define GNU_DEBUGLINK   ".gnu_debuglink"
1023 /*
1024 FUNCTION
1025         bfd_calc_gnu_debuglink_crc32
1026
1027 SYNOPSIS
1028         unsigned long bfd_calc_gnu_debuglink_crc32
1029           (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1030
1031 DESCRIPTION
1032         Computes a CRC value as used in the .gnu_debuglink section.
1033         Advances the previously computed @var{crc} value by computing
1034         and adding in the crc32 for @var{len} bytes of @var{buf}.
1035
1036 RETURNS
1037         Return the updated CRC32 value.
1038 */
1039
1040 unsigned long
1041 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1042                               const unsigned char *buf,
1043                               bfd_size_type len)
1044 {
1045   static const unsigned long crc32_table[256] =
1046     {
1047       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1048       0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1049       0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1050       0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1051       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1052       0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1053       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1054       0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1055       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1056       0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1057       0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1058       0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1059       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1060       0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1061       0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1062       0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1063       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1064       0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1065       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1066       0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1067       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1068       0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1069       0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1070       0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1071       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1072       0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1073       0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1074       0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1075       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1076       0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1077       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1078       0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1079       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1080       0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1081       0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1082       0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1083       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1084       0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1085       0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1086       0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1087       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1088       0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1089       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1090       0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1091       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1092       0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1093       0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1094       0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1095       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1096       0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1097       0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1098       0x2d02ef8d
1099     };
1100   const unsigned char *end;
1101
1102   crc = ~crc & 0xffffffff;
1103   for (end = buf + len; buf < end; ++ buf)
1104     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1105   return ~crc & 0xffffffff;;
1106 }
1107
1108
1109 /*
1110 INTERNAL_FUNCTION
1111         get_debug_link_info
1112
1113 SYNOPSIS
1114         char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1115
1116 DESCRIPTION
1117         fetch the filename and CRC32 value for any separate debuginfo
1118         associated with @var{abfd}. Return NULL if no such info found,
1119         otherwise return filename and update @var{crc32_out}.
1120 */
1121
1122 static char *
1123 get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1124 {
1125   asection *sect;
1126   unsigned long crc32;
1127   bfd_byte *contents;
1128   int crc_offset;
1129   char *name;
1130
1131   BFD_ASSERT (abfd);
1132   BFD_ASSERT (crc32_out);
1133
1134   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1135
1136   if (sect == NULL)
1137     return NULL;
1138
1139   if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1140     {
1141       if (contents != NULL)
1142         free (contents);
1143       return NULL;
1144     }
1145
1146   /* Crc value is stored after the filename, aligned up to 4 bytes.  */
1147   name = (char *) contents;
1148   crc_offset = strlen (name) + 1;
1149   crc_offset = (crc_offset + 3) & ~3;
1150
1151   crc32 = bfd_get_32 (abfd, contents + crc_offset);
1152
1153   *crc32_out = crc32;
1154   return name;
1155 }
1156
1157 /*
1158 INTERNAL_FUNCTION
1159         separate_debug_file_exists
1160
1161 SYNOPSIS
1162         bfd_boolean separate_debug_file_exists
1163           (char *name, unsigned long crc32);
1164
1165 DESCRIPTION
1166         Checks to see if @var{name} is a file and if its contents
1167         match @var{crc32}.
1168 */
1169
1170 static bfd_boolean
1171 separate_debug_file_exists (const char *name, const unsigned long crc)
1172 {
1173   static unsigned char buffer [8 * 1024];
1174   unsigned long file_crc = 0;
1175   int fd;
1176   bfd_size_type count;
1177
1178   BFD_ASSERT (name);
1179
1180   fd = open (name, O_RDONLY);
1181   if (fd < 0)
1182     return FALSE;
1183
1184   while ((count = read (fd, buffer, sizeof (buffer))) > 0)
1185     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1186
1187   close (fd);
1188
1189   return crc == file_crc;
1190 }
1191
1192
1193 /*
1194 INTERNAL_FUNCTION
1195         find_separate_debug_file
1196
1197 SYNOPSIS
1198         char *find_separate_debug_file (bfd *abfd);
1199
1200 DESCRIPTION
1201         Searches @var{abfd} for a reference to separate debugging
1202         information, scans various locations in the filesystem, including
1203         the file tree rooted at @var{debug_file_directory}, and returns a
1204         filename of such debugging information if the file is found and has
1205         matching CRC32.  Returns NULL if no reference to debugging file
1206         exists, or file cannot be found.
1207 */
1208
1209 static char *
1210 find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1211 {
1212   char *basename;
1213   char *dir;
1214   char *debugfile;
1215   unsigned long crc32;
1216   int i;
1217
1218   BFD_ASSERT (abfd);
1219   if (debug_file_directory == NULL)
1220     debug_file_directory = ".";
1221
1222   /* BFD may have been opened from a stream.  */
1223   if (! abfd->filename)
1224     return NULL;
1225
1226   basename = get_debug_link_info (abfd, & crc32);
1227   if (basename == NULL)
1228     return NULL;
1229
1230   if (strlen (basename) < 1)
1231     {
1232       free (basename);
1233       return NULL;
1234     }
1235
1236   dir = strdup (abfd->filename);
1237   if (dir == NULL)
1238     {
1239       free (basename);
1240       return NULL;
1241     }
1242   BFD_ASSERT (strlen (dir) != 0);
1243
1244   /* Strip off filename part.  */
1245   for (i = strlen (dir) - 1; i >= 0; i--)
1246     if (IS_DIR_SEPARATOR (dir[i]))
1247       break;
1248
1249   dir[i + 1] = '\0';
1250   BFD_ASSERT (dir[i] == '/' || dir[0] == '\0');
1251
1252   debugfile = malloc (strlen (debug_file_directory) + 1
1253                       + strlen (dir)
1254                       + strlen (".debug/")
1255                       + strlen (basename)
1256                       + 1);
1257   if (debugfile == NULL)
1258     {
1259       free (basename);
1260       free (dir);
1261       return NULL;
1262     }
1263
1264   /* First try in the same directory as the original file:  */
1265   strcpy (debugfile, dir);
1266   strcat (debugfile, basename);
1267
1268   if (separate_debug_file_exists (debugfile, crc32))
1269     {
1270       free (basename);
1271       free (dir);
1272       return debugfile;
1273     }
1274
1275   /* Then try in a subdirectory called .debug.  */
1276   strcpy (debugfile, dir);
1277   strcat (debugfile, ".debug/");
1278   strcat (debugfile, basename);
1279
1280   if (separate_debug_file_exists (debugfile, crc32))
1281     {
1282       free (basename);
1283       free (dir);
1284       return debugfile;
1285     }
1286
1287   /* Then try in the global debugfile directory.  */
1288   strcpy (debugfile, debug_file_directory);
1289   i = strlen (debug_file_directory) - 1;
1290   if (i > 0
1291       && debug_file_directory[i] != '/'
1292       && dir[0] != '/')
1293     strcat (debugfile, "/");
1294   strcat (debugfile, dir);
1295   strcat (debugfile, basename);
1296
1297   if (separate_debug_file_exists (debugfile, crc32))
1298     {
1299       free (basename);
1300       free (dir);
1301       return debugfile;
1302     }
1303
1304   free (debugfile);
1305   free (basename);
1306   free (dir);
1307   return NULL;
1308 }
1309
1310
1311 /*
1312 FUNCTION
1313         bfd_follow_gnu_debuglink
1314
1315 SYNOPSIS
1316         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1317
1318 DESCRIPTION
1319
1320         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1321         section is found, it examines the section for the name and checksum
1322         of a '.debug' file containing auxiliary debugging information.  It
1323         then searches the filesystem for this .debug file in some standard
1324         locations, including the directory tree rooted at @var{dir}, and if
1325         found returns the full filename.
1326
1327         If @var{dir} is NULL, it will search a default path configured into
1328         libbfd at build time.  [XXX this feature is not currently
1329         implemented].
1330
1331 RETURNS
1332         <<NULL>> on any errors or failure to locate the .debug file,
1333         otherwise a pointer to a heap-allocated string containing the
1334         filename.  The caller is responsible for freeing this string.
1335 */
1336
1337 char *
1338 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1339 {
1340   return find_separate_debug_file (abfd, dir);
1341 }
1342
1343 /*
1344 FUNCTION
1345         bfd_create_gnu_debuglink_section
1346
1347 SYNOPSIS
1348         struct bfd_section *bfd_create_gnu_debuglink_section
1349           (bfd *abfd, const char *filename);
1350
1351 DESCRIPTION
1352
1353         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The section is sized
1354         to be big enough to contain a link to the specified @var{filename}.
1355
1356 RETURNS
1357         A pointer to the new section is returned if all is ok.  Otherwise <<NULL>> is
1358         returned and bfd_error is set.
1359 */
1360
1361 asection *
1362 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1363 {
1364   asection *sect;
1365   bfd_size_type debuglink_size;
1366   flagword flags;
1367
1368   if (abfd == NULL || filename == NULL)
1369     {
1370       bfd_set_error (bfd_error_invalid_operation);
1371       return NULL;
1372     }
1373
1374   /* Strip off any path components in filename.  */
1375   filename = lbasename (filename);
1376
1377   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1378   if (sect)
1379     {
1380       /* Section already exists.  */
1381       bfd_set_error (bfd_error_invalid_operation);
1382       return NULL;
1383     }
1384
1385   flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1386   sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1387   if (sect == NULL)
1388     return NULL;
1389
1390   debuglink_size = strlen (filename) + 1;
1391   debuglink_size += 3;
1392   debuglink_size &= ~3;
1393   debuglink_size += 4;
1394
1395   if (! bfd_set_section_size (abfd, sect, debuglink_size))
1396     /* XXX Should we delete the section from the bfd ?  */
1397     return NULL;
1398
1399   return sect;
1400 }
1401
1402
1403 /*
1404 FUNCTION
1405         bfd_fill_in_gnu_debuglink_section
1406
1407 SYNOPSIS
1408         bfd_boolean bfd_fill_in_gnu_debuglink_section
1409           (bfd *abfd, struct bfd_section *sect, const char *filename);
1410
1411 DESCRIPTION
1412
1413         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1414         and fills in the contents of the section to contain a link to the
1415         specified @var{filename}.  The filename should be relative to the
1416         current directory.
1417
1418 RETURNS
1419         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1420         and bfd_error is set.
1421 */
1422
1423 bfd_boolean
1424 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1425                                    struct bfd_section *sect,
1426                                    const char *filename)
1427 {
1428   bfd_size_type debuglink_size;
1429   unsigned long crc32;
1430   char * contents;
1431   bfd_size_type crc_offset;
1432   FILE * handle;
1433   static unsigned char buffer[8 * 1024];
1434   size_t count;
1435
1436   if (abfd == NULL || sect == NULL || filename == NULL)
1437     {
1438       bfd_set_error (bfd_error_invalid_operation);
1439       return FALSE;
1440     }
1441
1442   /* Make sure that we can read the file.
1443      XXX - Should we attempt to locate the debug info file using the same
1444      algorithm as gdb ?  At the moment, since we are creating the
1445      .gnu_debuglink section, we insist upon the user providing us with a
1446      correct-for-section-creation-time path, but this need not conform to
1447      the gdb location algorithm.  */
1448   handle = real_fopen (filename, FOPEN_RB);
1449   if (handle == NULL)
1450     {
1451       bfd_set_error (bfd_error_system_call);
1452       return FALSE;
1453     }
1454
1455   crc32 = 0;
1456   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1457     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1458   fclose (handle);
1459
1460   /* Strip off any path components in filename,
1461      now that we no longer need them.  */
1462   filename = lbasename (filename);
1463
1464   debuglink_size = strlen (filename) + 1;
1465   debuglink_size += 3;
1466   debuglink_size &= ~3;
1467   debuglink_size += 4;
1468
1469   contents = malloc (debuglink_size);
1470   if (contents == NULL)
1471     {
1472       /* XXX Should we delete the section from the bfd ?  */
1473       bfd_set_error (bfd_error_no_memory);
1474       return FALSE;
1475     }
1476
1477   strcpy (contents, filename);
1478   crc_offset = debuglink_size - 4;
1479
1480   bfd_put_32 (abfd, crc32, contents + crc_offset);
1481
1482   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1483     {
1484       /* XXX Should we delete the section from the bfd ?  */
1485       free (contents);
1486       return FALSE;
1487     }
1488
1489   return TRUE;
1490 }