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