contrib/binutils-2.25/bfd/opncls.c

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