bfd/opncls.c

   1 /* opncls.c -- open and close a BFD.
   2    Copyright (C) 1990-2023 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 #include "elf-bfd.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 /*
  41 SECTION
  42         Opening and closing BFDs
  43
  44 SUBSECTION
  45         Functions for opening and closing
  46 */
  47
  48 /* Counters used to initialize the bfd identifier.  */
  49
  50 static unsigned int bfd_id_counter = 0;
  51 static unsigned int bfd_reserved_id_counter = 0;
  52
  53 /*
  54 EXTERNAL
  55 .{* Set to N to open the next N BFDs using an alternate id space.  *}
  56 .extern unsigned int bfd_use_reserved_id;
  57 .
  58 */
  59 unsigned int bfd_use_reserved_id = 0;
  60
  61 /* fdopen is a loser -- we should use stdio exclusively.  Unfortunately
  62    if we do that we can't use fcntl.  */
  63
  64 /*
  65 INTERNAL_FUNCTION
  66         _bfd_new_bfd
  67
  68 SYNOPSIS
  69         bfd *_bfd_new_bfd (void);
  70
  71 DESCRIPTION
  72         Return a new BFD.  All BFD's are allocated through this routine.
  73 */
  74
  75 bfd *
  76 _bfd_new_bfd (void)
  77 {
  78   bfd *nbfd;
  79
  80   nbfd = (bfd *) bfd_zmalloc (sizeof (bfd));
  81   if (nbfd == NULL)
  82     return NULL;
  83
  84   if (bfd_use_reserved_id)
  85     {
  86       nbfd->id = --bfd_reserved_id_counter;
  87       --bfd_use_reserved_id;
  88     }
  89   else
  90     nbfd->id = bfd_id_counter++;
  91
  92   nbfd->memory = objalloc_create ();
  93   if (nbfd->memory == NULL)
  94     {
  95       bfd_set_error (bfd_error_no_memory);
  96       free (nbfd);
  97       return NULL;
  98     }
  99
 100   nbfd->arch_info = &bfd_default_arch_struct;
 101
 102   if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
 103                               sizeof (struct section_hash_entry), 13))
 104     {
 105       objalloc_free ((struct objalloc *) nbfd->memory);
 106       free (nbfd);
 107       return NULL;
 108     }
 109
 110   nbfd->archive_plugin_fd = -1;
 111
 112   return nbfd;
 113 }
 114
 115 static const struct bfd_iovec opncls_iovec;
 116
 117 /*
 118 INTERNAL_FUNCTION
 119         _bfd_new_bfd_contained_in
 120
 121 SYNOPSIS
 122         bfd *_bfd_new_bfd_contained_in (bfd *);
 123
 124 DESCRIPTION
 125         Allocate a new BFD as a member of archive OBFD.
 126 */
 127
 128 bfd *
 129 _bfd_new_bfd_contained_in (bfd *obfd)
 130 {
 131   bfd *nbfd;
 132
 133   /* Nested archives in bims are unsupported.  */
 134   if ((obfd->flags & BFD_IN_MEMORY) != 0)
 135     {
 136       bfd_set_error (bfd_error_malformed_archive);
 137       return NULL;
 138     }
 139   nbfd = _bfd_new_bfd ();
 140   if (nbfd == NULL)
 141     return NULL;
 142   nbfd->xvec = obfd->xvec;
 143   nbfd->iovec = obfd->iovec;
 144   if (obfd->iovec == &opncls_iovec)
 145     nbfd->iostream = obfd->iostream;
 146   nbfd->my_archive = obfd;
 147   nbfd->direction = read_direction;
 148   nbfd->target_defaulted = obfd->target_defaulted;
 149   nbfd->lto_output = obfd->lto_output;
 150   nbfd->no_export = obfd->no_export;
 151   return nbfd;
 152 }
 153
 154 /* Delete a BFD.  */
 155
 156 static void
 157 _bfd_delete_bfd (bfd *abfd)
 158 {
 159   /* Give the target _bfd_free_cached_info a chance to free memory.  */
 160   if (abfd->memory && abfd->xvec)
 161     bfd_free_cached_info (abfd);
 162
 163   /* The target _bfd_free_cached_info may not have done anything..  */
 164   if (abfd->memory)
 165     {
 166       bfd_hash_table_free (&abfd->section_htab);
 167       objalloc_free ((struct objalloc *) abfd->memory);
 168     }
 169   else
 170     free ((char *) bfd_get_filename (abfd));
 171
 172   free (abfd->arelt_data);
 173   free (abfd);
 174 }
 175
 176 /*
 177 INTERNAL_FUNCTION
 178         _bfd_free_cached_info
 179
 180 SYNOPSIS
 181         bool _bfd_free_cached_info (bfd *);
 182
 183 DESCRIPTION
 184         Free objalloc memory.
 185 */
 186
 187 bool
 188 _bfd_free_cached_info (bfd *abfd)
 189 {
 190   if (abfd->memory)
 191     {
 192       const char *filename = bfd_get_filename (abfd);
 193       if (filename)
 194         {
 195           /* We can't afford to lose the bfd filename when freeing
 196              abfd->memory, because that would kill the cache.c scheme
 197              of closing and reopening files in order to limit the
 198              number of open files.  To reopen, you need the filename.
 199              And indeed _bfd_compute_and_write_armap calls
 200              _bfd_free_cached_info to free up space used by symbols
 201              and by check_format_matches.  Which we want to continue
 202              doing to handle very large archives.  Later the archive
 203              elements are copied, which might require reopening files.
 204              We also want to keep using objalloc memory for the
 205              filename since that allows the name to be updated
 206              without either leaking memory or implementing some sort
 207              of reference counted string for copies of the filename.  */
 208           size_t len = strlen (filename) + 1;
 209           char *copy = bfd_malloc (len);
 210           if (copy == NULL)
 211             return false;
 212           memcpy (copy, filename, len);
 213           abfd->filename = copy;
 214         }
 215       bfd_hash_table_free (&abfd->section_htab);
 216       objalloc_free ((struct objalloc *) abfd->memory);
 217
 218       abfd->sections = NULL;
 219       abfd->section_last = NULL;
 220       abfd->outsymbols = NULL;
 221       abfd->tdata.any = NULL;
 222       abfd->usrdata = NULL;
 223       abfd->memory = NULL;
 224     }
 225
 226   return true;
 227 }
 228
 229 /*
 230 FUNCTION
 231         bfd_fopen
 232
 233 SYNOPSIS
 234         bfd *bfd_fopen (const char *filename, const char *target,
 235                         const char *mode, int fd);
 236
 237 DESCRIPTION
 238         Open the file @var{filename} with the target @var{target}.
 239         Return a pointer to the created BFD.  If @var{fd} is not -1,
 240         then <<fdopen>> is used to open the file; otherwise, <<fopen>>
 241         is used.  @var{mode} is passed directly to <<fopen>> or
 242         <<fdopen>>.
 243
 244         Calls <<bfd_find_target>>, so @var{target} is interpreted as by
 245         that function.
 246
 247         The new BFD is marked as cacheable iff @var{fd} is -1.
 248
 249         If <<NULL>> is returned then an error has occured.   Possible errors
 250         are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
 251         <<system_call>> error.
 252
 253         On error, @var{fd} is always closed.
 254
 255         A copy of the @var{filename} argument is stored in the newly created
 256         BFD.  It can be accessed via the bfd_get_filename() macro.
 257 */
 258
 259 bfd *
 260 bfd_fopen (const char *filename, const char *target, const char *mode, int fd)
 261 {
 262   bfd *nbfd;
 263   const bfd_target *target_vec;
 264
 265   nbfd = _bfd_new_bfd ();
 266   if (nbfd == NULL)
 267     {
 268       if (fd != -1)
 269         close (fd);
 270       return NULL;
 271     }
 272
 273   target_vec = bfd_find_target (target, nbfd);
 274   if (target_vec == NULL)
 275     {
 276       if (fd != -1)
 277         close (fd);
 278       _bfd_delete_bfd (nbfd);
 279       return NULL;
 280     }
 281
 282 #ifdef HAVE_FDOPEN
 283   if (fd != -1)
 284     nbfd->iostream = fdopen (fd, mode);
 285   else
 286 #endif
 287     nbfd->iostream = _bfd_real_fopen (filename, mode);
 288   if (nbfd->iostream == NULL)
 289     {
 290       bfd_set_error (bfd_error_system_call);
 291       if (fd != -1)
 292         close (fd);
 293       _bfd_delete_bfd (nbfd);
 294       return NULL;
 295     }
 296
 297   /* OK, put everything where it belongs.  */
 298
 299   /* PR 11983: Do not cache the original filename, but
 300      rather make a copy - the original might go away.  */
 301   if (!bfd_set_filename (nbfd, filename))
 302     {
 303       fclose (nbfd->iostream);
 304       _bfd_delete_bfd (nbfd);
 305       return NULL;
 306     }
 307
 308   /* Figure out whether the user is opening the file for reading,
 309      writing, or both, by looking at the MODE argument.  */
 310   if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')
 311       && mode[1] == '+')
 312     nbfd->direction = both_direction;
 313   else if (mode[0] == 'r')
 314     nbfd->direction = read_direction;
 315   else
 316     nbfd->direction = write_direction;
 317
 318   if (!bfd_cache_init (nbfd))
 319     {
 320       fclose (nbfd->iostream);
 321       _bfd_delete_bfd (nbfd);
 322       return NULL;
 323     }
 324   nbfd->opened_once = true;
 325
 326   /* If we opened the file by name, mark it cacheable; we can close it
 327      and reopen it later.  However, if a file descriptor was provided,
 328      then it may have been opened with special flags that make it
 329      unsafe to close and reopen the file.  */
 330   if (fd == -1)
 331     (void) bfd_set_cacheable (nbfd, true);
 332
 333   return nbfd;
 334 }
 335
 336 /*
 337 FUNCTION
 338         bfd_openr
 339
 340 SYNOPSIS
 341         bfd *bfd_openr (const char *filename, const char *target);
 342
 343 DESCRIPTION
 344         Open the file @var{filename} (using <<fopen>>) with the target
 345         @var{target}.  Return a pointer to the created BFD.
 346
 347         Calls <<bfd_find_target>>, so @var{target} is interpreted as by
 348         that function.
 349
 350         If <<NULL>> is returned then an error has occured.   Possible errors
 351         are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
 352         <<system_call>> error.
 353
 354         A copy of the @var{filename} argument is stored in the newly created
 355         BFD.  It can be accessed via the bfd_get_filename() macro.
 356 */
 357
 358 bfd *
 359 bfd_openr (const char *filename, const char *target)
 360 {
 361   return bfd_fopen (filename, target, FOPEN_RB, -1);
 362 }
 363
 364 /* Don't try to `optimize' this function:
 365
 366    o - We lock using stack space so that interrupting the locking
 367        won't cause a storage leak.
 368    o - We open the file stream last, since we don't want to have to
 369        close it if anything goes wrong.  Closing the stream means closing
 370        the file descriptor too, even though we didn't open it.  */
 371 /*
 372 FUNCTION
 373         bfd_fdopenr
 374
 375 SYNOPSIS
 376         bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
 377
 378 DESCRIPTION
 379         <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
 380         <<fopen>>.  It opens a BFD on a file already described by the
 381         @var{fd} supplied.
 382
 383         When the file is later <<bfd_close>>d, the file descriptor will
 384         be closed.  If the caller desires that this file descriptor be
 385         cached by BFD (opened as needed, closed as needed to free
 386         descriptors for other opens), with the supplied @var{fd} used as
 387         an initial file descriptor (but subject to closure at any time),
 388         call bfd_set_cacheable(bfd, 1) on the returned BFD.  The default
 389         is to assume no caching; the file descriptor will remain open
 390         until <<bfd_close>>, and will not be affected by BFD operations
 391         on other files.
 392
 393         Possible errors are <<bfd_error_no_memory>>,
 394         <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
 395
 396         On error, @var{fd} is closed.
 397
 398         A copy of the @var{filename} argument is stored in the newly created
 399         BFD.  It can be accessed via the bfd_get_filename() macro.
 400 */
 401
 402 bfd *
 403 bfd_fdopenr (const char *filename, const char *target, int fd)
 404 {
 405   const char *mode;
 406 #if defined(HAVE_FCNTL) && defined(F_GETFL)
 407   int fdflags;
 408 #endif
 409
 410 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
 411   mode = FOPEN_RUB; /* Assume full access.  */
 412 #else
 413   fdflags = fcntl (fd, F_GETFL, NULL);
 414   if (fdflags == -1)
 415     {
 416       int save = errno;
 417
 418       close (fd);
 419       errno = save;
 420       bfd_set_error (bfd_error_system_call);
 421       return NULL;
 422     }
 423
 424   /* (O_ACCMODE) parens are to avoid Ultrix header file bug.  */
 425   switch (fdflags & (O_ACCMODE))
 426     {
 427     case O_RDONLY: mode = FOPEN_RB; break;
 428     case O_WRONLY: mode = FOPEN_RUB; break;
 429     case O_RDWR:   mode = FOPEN_RUB; break;
 430     default: abort ();
 431     }
 432 #endif
 433
 434   return bfd_fopen (filename, target, mode, fd);
 435 }
 436
 437 /*
 438 FUNCTION
 439         bfd_fdopenw
 440
 441 SYNOPSIS
 442         bfd *bfd_fdopenw (const char *filename, const char *target, int fd);
 443
 444 DESCRIPTION
 445         <<bfd_fdopenw>> is exactly like <<bfd_fdopenr>> with the exception that
 446         the resulting BFD is suitable for output.
 447 */
 448
 449 bfd *
 450 bfd_fdopenw (const char *filename, const char *target, int fd)
 451 {
 452   bfd *out = bfd_fdopenr (filename, target, fd);
 453
 454   if (out != NULL)
 455     {
 456       if (!bfd_write_p (out))
 457         {
 458           close (fd);
 459           _bfd_delete_bfd (out);
 460           out = NULL;
 461           bfd_set_error (bfd_error_invalid_operation);
 462         }
 463       else
 464         out->direction = write_direction;
 465     }
 466
 467   return out;
 468 }
 469
 470 /*
 471 FUNCTION
 472         bfd_openstreamr
 473
 474 SYNOPSIS
 475         bfd *bfd_openstreamr (const char * filename, const char * target,
 476                               void * stream);
 477
 478 DESCRIPTION
 479         Open a BFD for read access on an existing stdio stream.  When
 480         the BFD is passed to <<bfd_close>>, the stream will be closed.
 481
 482         A copy of the @var{filename} argument is stored in the newly created
 483         BFD.  It can be accessed via the bfd_get_filename() macro.
 484 */
 485
 486 bfd *
 487 bfd_openstreamr (const char *filename, const char *target, void *streamarg)
 488 {
 489   FILE *stream = (FILE *) streamarg;
 490   bfd *nbfd;
 491   const bfd_target *target_vec;
 492
 493   nbfd = _bfd_new_bfd ();
 494   if (nbfd == NULL)
 495     return NULL;
 496
 497   target_vec = bfd_find_target (target, nbfd);
 498   if (target_vec == NULL)
 499     {
 500       _bfd_delete_bfd (nbfd);
 501       return NULL;
 502     }
 503
 504   nbfd->iostream = stream;
 505   /* PR 11983: Do not cache the original filename, but
 506      rather make a copy - the original might go away.  */
 507   if (!bfd_set_filename (nbfd, filename))
 508     {
 509       _bfd_delete_bfd (nbfd);
 510       return NULL;
 511     }
 512   nbfd->direction = read_direction;
 513
 514   if (! bfd_cache_init (nbfd))
 515     {
 516       _bfd_delete_bfd (nbfd);
 517       return NULL;
 518     }
 519
 520   return nbfd;
 521 }
 522
 523 /*
 524 FUNCTION
 525         bfd_openr_iovec
 526
 527 SYNOPSIS
 528         bfd *bfd_openr_iovec (const char *filename, const char *target,
 529                               void *(*open_func) (struct bfd *nbfd,
 530                                                   void *open_closure),
 531                               void *open_closure,
 532                               file_ptr (*pread_func) (struct bfd *nbfd,
 533                                                       void *stream,
 534                                                       void *buf,
 535                                                       file_ptr nbytes,
 536                                                       file_ptr offset),
 537                               int (*close_func) (struct bfd *nbfd,
 538                                                  void *stream),
 539                               int (*stat_func) (struct bfd *abfd,
 540                                                 void *stream,
 541                                                 struct stat *sb));
 542
 543 DESCRIPTION
 544         Create and return a BFD backed by a read-only @var{stream}.
 545         The @var{stream} is created using @var{open_func}, accessed using
 546         @var{pread_func} and destroyed using @var{close_func}.
 547
 548         Calls <<bfd_find_target>>, so @var{target} is interpreted as by
 549         that function.
 550
 551         Calls @var{open_func} (which can call <<bfd_zalloc>> and
 552         <<bfd_get_filename>>) to obtain the read-only stream backing
 553         the BFD.  @var{open_func} either succeeds returning the
 554         non-<<NULL>> @var{stream}, or fails returning <<NULL>>
 555         (setting <<bfd_error>>).
 556
 557         Calls @var{pread_func} to request @var{nbytes} of data from
 558         @var{stream} starting at @var{offset} (e.g., via a call to
 559         <<bfd_read>>).  @var{pread_func} either succeeds returning the
 560         number of bytes read (which can be less than @var{nbytes} when
 561         end-of-file), or fails returning -1 (setting <<bfd_error>>).
 562
 563         Calls @var{close_func} when the BFD is later closed using
 564         <<bfd_close>>.  @var{close_func} either succeeds returning 0, or
 565         fails returning -1 (setting <<bfd_error>>).
 566
 567         Calls @var{stat_func} to fill in a stat structure for bfd_stat,
 568         bfd_get_size, and bfd_get_mtime calls.  @var{stat_func} returns 0
 569         on success, or returns -1 on failure (setting <<bfd_error>>).
 570
 571         If <<bfd_openr_iovec>> returns <<NULL>> then an error has
 572         occurred.  Possible errors are <<bfd_error_no_memory>>,
 573         <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
 574
 575         A copy of the @var{filename} argument is stored in the newly created
 576         BFD.  It can be accessed via the bfd_get_filename() macro.
 577 */
 578
 579 struct opncls
 580 {
 581   void *stream;
 582   file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,
 583                      file_ptr nbytes, file_ptr offset);
 584   int (*close) (struct bfd *abfd, void *stream);
 585   int (*stat) (struct bfd *abfd, void *stream, struct stat *sb);
 586   file_ptr where;
 587 };
 588
 589 static file_ptr
 590 opncls_btell (struct bfd *abfd)
 591 {
 592   struct opncls *vec = (struct opncls *) abfd->iostream;
 593   return vec->where;
 594 }
 595
 596 static int
 597 opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)
 598 {
 599   struct opncls *vec = (struct opncls *) abfd->iostream;
 600   switch (whence)
 601     {
 602     case SEEK_SET: vec->where = offset; break;
 603     case SEEK_CUR: vec->where += offset; break;
 604     case SEEK_END: return -1;
 605     }
 606   return 0;
 607 }
 608
 609 static file_ptr
 610 opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
 611 {
 612   struct opncls *vec = (struct opncls *) abfd->iostream;
 613   file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where);
 614
 615   if (nread < 0)
 616     return nread;
 617   vec->where += nread;
 618   return nread;
 619 }
 620
 621 static file_ptr
 622 opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
 623               const void *where ATTRIBUTE_UNUSED,
 624               file_ptr nbytes ATTRIBUTE_UNUSED)
 625 {
 626   return -1;
 627 }
 628
 629 static int
 630 opncls_bclose (struct bfd *abfd)
 631 {
 632   struct opncls *vec = (struct opncls *) abfd->iostream;
 633   /* Since the VEC's memory is bound to the bfd deleting the bfd will
 634      free it.  */
 635   int status = 0;
 636
 637   if (vec->close != NULL)
 638     status = (vec->close) (abfd, vec->stream);
 639   abfd->iostream = NULL;
 640   return status;
 641 }
 642
 643 static int
 644 opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
 645 {
 646   return 0;
 647 }
 648
 649 static int
 650 opncls_bstat (struct bfd *abfd, struct stat *sb)
 651 {
 652   struct opncls *vec = (struct opncls *) abfd->iostream;
 653
 654   memset (sb, 0, sizeof (*sb));
 655   if (vec->stat == NULL)
 656     return 0;
 657
 658   return (vec->stat) (abfd, vec->stream, sb);
 659 }
 660
 661 static void *
 662 opncls_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
 663               void *addr ATTRIBUTE_UNUSED,
 664               bfd_size_type len ATTRIBUTE_UNUSED,
 665               int prot ATTRIBUTE_UNUSED,
 666               int flags ATTRIBUTE_UNUSED,
 667               file_ptr offset ATTRIBUTE_UNUSED,
 668               void **map_addr ATTRIBUTE_UNUSED,
 669               bfd_size_type *map_len ATTRIBUTE_UNUSED)
 670 {
 671   return (void *) -1;
 672 }
 673
 674 static const struct bfd_iovec opncls_iovec =
 675 {
 676   &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
 677   &opncls_bclose, &opncls_bflush, &opncls_bstat, &opncls_bmmap
 678 };
 679
 680 bfd *
 681 bfd_openr_iovec (const char *filename, const char *target,
 682                  void *(*open_p) (struct bfd *, void *),
 683                  void *open_closure,
 684                  file_ptr (*pread_p) (struct bfd *, void *, void *,
 685                                       file_ptr, file_ptr),
 686                  int (*close_p) (struct bfd *, void *),
 687                  int (*stat_p) (struct bfd *, void *, struct stat *))
 688 {
 689   bfd *nbfd;
 690   const bfd_target *target_vec;
 691   struct opncls *vec;
 692   void *stream;
 693
 694   nbfd = _bfd_new_bfd ();
 695   if (nbfd == NULL)
 696     return NULL;
 697
 698   target_vec = bfd_find_target (target, nbfd);
 699   if (target_vec == NULL)
 700     {
 701       _bfd_delete_bfd (nbfd);
 702       return NULL;
 703     }
 704
 705   /* PR 11983: Do not cache the original filename, but
 706      rather make a copy - the original might go away.  */
 707   if (!bfd_set_filename (nbfd, filename))
 708     {
 709       _bfd_delete_bfd (nbfd);
 710       return NULL;
 711     }
 712   nbfd->direction = read_direction;
 713
 714   /* `open_p (...)' would get expanded by an the open(2) syscall macro.  */
 715   stream = (*open_p) (nbfd, open_closure);
 716   if (stream == NULL)
 717     {
 718       _bfd_delete_bfd (nbfd);
 719       return NULL;
 720     }
 721
 722   vec = (struct opncls *) bfd_zalloc (nbfd, sizeof (struct opncls));
 723   vec->stream = stream;
 724   vec->pread = pread_p;
 725   vec->close = close_p;
 726   vec->stat = stat_p;
 727
 728   nbfd->iovec = &opncls_iovec;
 729   nbfd->iostream = vec;
 730
 731   return nbfd;
 732 }
 733 \f
 734 /* bfd_openw -- open for writing.
 735    Returns a pointer to a freshly-allocated BFD on success, or NULL.
 736
 737    See comment by bfd_fdopenr before you try to modify this function.  */
 738
 739 /*
 740 FUNCTION
 741         bfd_openw
 742
 743 SYNOPSIS
 744         bfd *bfd_openw (const char *filename, const char *target);
 745
 746 DESCRIPTION
 747         Create a BFD, associated with file @var{filename}, using the
 748         file format @var{target}, and return a pointer to it.
 749
 750         Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
 751         <<bfd_error_invalid_target>>.
 752
 753         A copy of the @var{filename} argument is stored in the newly created
 754         BFD.  It can be accessed via the bfd_get_filename() macro.
 755 */
 756
 757 bfd *
 758 bfd_openw (const char *filename, const char *target)
 759 {
 760   bfd *nbfd;
 761   const bfd_target *target_vec;
 762
 763   /* nbfd has to point to head of malloc'ed block so that bfd_close may
 764      reclaim it correctly.  */
 765   nbfd = _bfd_new_bfd ();
 766   if (nbfd == NULL)
 767     return NULL;
 768
 769   target_vec = bfd_find_target (target, nbfd);
 770   if (target_vec == NULL)
 771     {
 772       _bfd_delete_bfd (nbfd);
 773       return NULL;
 774     }
 775
 776   /* PR 11983: Do not cache the original filename, but
 777      rather make a copy - the original might go away.  */
 778   if (!bfd_set_filename (nbfd, filename))
 779     {
 780       _bfd_delete_bfd (nbfd);
 781       return NULL;
 782     }
 783   nbfd->direction = write_direction;
 784
 785   if (bfd_open_file (nbfd) == NULL)
 786     {
 787       /* File not writeable, etc.  */
 788       bfd_set_error (bfd_error_system_call);
 789       _bfd_delete_bfd (nbfd);
 790       return NULL;
 791   }
 792
 793   return nbfd;
 794 }
 795
 796 /*
 797 FUNCTION
 798         bfd_elf_bfd_from_remote_memory
 799
 800 SYNOPSIS
 801         bfd *bfd_elf_bfd_from_remote_memory
 802           (bfd *templ, bfd_vma ehdr_vma, bfd_size_type size, bfd_vma *loadbasep,
 803            int (*target_read_memory)
 804              (bfd_vma vma, bfd_byte *myaddr, bfd_size_type len));
 805
 806 DESCRIPTION
 807         Create a new BFD as if by bfd_openr.  Rather than opening a
 808         file, reconstruct an ELF file by reading the segments out of
 809         remote memory based on the ELF file header at EHDR_VMA and the
 810         ELF program headers it points to.  If non-zero, SIZE is the
 811         known extent of the object.  If not null, *LOADBASEP is filled
 812         in with the difference between the VMAs from which the
 813         segments were read, and the VMAs the file headers (and hence
 814         BFD's idea of each section's VMA) put them at.
 815
 816         The function TARGET_READ_MEMORY is called to copy LEN bytes
 817         from the remote memory at target address VMA into the local
 818         buffer at MYADDR; it should return zero on success or an
 819         errno code on failure.  TEMPL must be a BFD for an ELF
 820         target with the word size and byte order found in the remote
 821         memory.
 822 */
 823
 824 bfd *
 825 bfd_elf_bfd_from_remote_memory
 826   (bfd *templ,
 827    bfd_vma ehdr_vma,
 828    bfd_size_type size,
 829    bfd_vma *loadbasep,
 830    int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type))
 831 {
 832   if (bfd_get_flavour (templ) != bfd_target_elf_flavour)
 833     {
 834       bfd_set_error (bfd_error_invalid_operation);
 835       return NULL;
 836     }
 837   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
 838     (templ, ehdr_vma, size, loadbasep, target_read_memory);
 839 }
 840
 841 static inline void
 842 _maybe_make_executable (bfd * abfd)
 843 {
 844   /* If the file was open for writing and is now executable,
 845      make it so.  */
 846   if (abfd->direction == write_direction
 847       && (abfd->flags & (EXEC_P | DYNAMIC)) != 0)
 848     {
 849       struct stat buf;
 850
 851       if (stat (bfd_get_filename (abfd), &buf) == 0
 852           /* Do not attempt to change non-regular files.  This is
 853              here especially for configure scripts and kernel builds
 854              which run tests with "ld [...] -o /dev/null".  */
 855           && S_ISREG(buf.st_mode))
 856         {
 857           unsigned int mask = umask (0);
 858
 859           umask (mask);
 860           chmod (bfd_get_filename (abfd),
 861                  (0777
 862                   & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
 863         }
 864     }
 865 }
 866
 867 /*
 868 FUNCTION
 869         bfd_close
 870
 871 SYNOPSIS
 872         bool bfd_close (bfd *abfd);
 873
 874 DESCRIPTION
 875         Close a BFD. If the BFD was open for writing, then pending
 876         operations are completed and the file written out and closed.
 877         If the created file is executable, then <<chmod>> is called
 878         to mark it as such.
 879
 880         All memory attached to the BFD is released.
 881
 882         The file descriptor associated with the BFD is closed (even
 883         if it was passed in to BFD by <<bfd_fdopenr>>).
 884
 885         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 886 */
 887
 888 bool
 889 bfd_close (bfd *abfd)
 890 {
 891   bool ret = (!bfd_write_p (abfd)
 892               || BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)));
 893
 894   return bfd_close_all_done (abfd) && ret;
 895 }
 896
 897 /*
 898 FUNCTION
 899         bfd_close_all_done
 900
 901 SYNOPSIS
 902         bool bfd_close_all_done (bfd *);
 903
 904 DESCRIPTION
 905         Close a BFD.  Differs from <<bfd_close>> since it does not
 906         complete any pending operations.  This routine would be used
 907         if the application had just used BFD for swapping and didn't
 908         want to use any of the writing code.
 909
 910         If the created file is executable, then <<chmod>> is called
 911         to mark it as such.
 912
 913         All memory attached to the BFD is released.
 914
 915         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 916 */
 917
 918 bool
 919 bfd_close_all_done (bfd *abfd)
 920 {
 921   bool ret = BFD_SEND (abfd, _close_and_cleanup, (abfd));
 922
 923   if (abfd->iovec != NULL)
 924     ret &= abfd->iovec->bclose (abfd) == 0;
 925
 926   if (ret)
 927     _maybe_make_executable (abfd);
 928
 929   _bfd_delete_bfd (abfd);
 930   free (_bfd_error_buf);
 931   _bfd_error_buf = NULL;
 932
 933   return ret;
 934 }
 935
 936 /*
 937 FUNCTION
 938         bfd_create
 939
 940 SYNOPSIS
 941         bfd *bfd_create (const char *filename, bfd *templ);
 942
 943 DESCRIPTION
 944         Create a new BFD in the manner of <<bfd_openw>>, but without
 945         opening a file. The new BFD takes the target from the target
 946         used by @var{templ}. The format is always set to <<bfd_object>>.
 947
 948         A copy of the @var{filename} argument is stored in the newly created
 949         BFD.  It can be accessed via the bfd_get_filename() macro.
 950 */
 951
 952 bfd *
 953 bfd_create (const char *filename, bfd *templ)
 954 {
 955   bfd *nbfd;
 956
 957   nbfd = _bfd_new_bfd ();
 958   if (nbfd == NULL)
 959     return NULL;
 960   /* PR 11983: Do not cache the original filename, but
 961      rather make a copy - the original might go away.  */
 962   if (!bfd_set_filename (nbfd, filename))
 963     {
 964       _bfd_delete_bfd (nbfd);
 965       return NULL;
 966     }
 967   if (templ)
 968     nbfd->xvec = templ->xvec;
 969   nbfd->direction = no_direction;
 970   bfd_set_format (nbfd, bfd_object);
 971
 972   return nbfd;
 973 }
 974
 975 /*
 976 FUNCTION
 977         bfd_make_writable
 978
 979 SYNOPSIS
 980         bool bfd_make_writable (bfd *abfd);
 981
 982 DESCRIPTION
 983         Takes a BFD as created by <<bfd_create>> and converts it
 984         into one like as returned by <<bfd_openw>>.  It does this
 985         by converting the BFD to BFD_IN_MEMORY.  It's assumed that
 986         you will call <<bfd_make_readable>> on this bfd later.
 987
 988         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 989 */
 990
 991 bool
 992 bfd_make_writable (bfd *abfd)
 993 {
 994   struct bfd_in_memory *bim;
 995
 996   if (abfd->direction != no_direction)
 997     {
 998       bfd_set_error (bfd_error_invalid_operation);
 999       return false;
1000     }
1001
1002   bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
1003   if (bim == NULL)
1004     return false;       /* bfd_error already set.  */
1005   abfd->iostream = bim;
1006   /* bfd_write will grow these as needed.  */
1007   bim->size = 0;
1008   bim->buffer = 0;
1009
1010   abfd->flags |= BFD_IN_MEMORY;
1011   abfd->iovec = &_bfd_memory_iovec;
1012   abfd->origin = 0;
1013   abfd->direction = write_direction;
1014   abfd->where = 0;
1015
1016   return true;
1017 }
1018
1019 /*
1020 FUNCTION
1021         bfd_make_readable
1022
1023 SYNOPSIS
1024         bool bfd_make_readable (bfd *abfd);
1025
1026 DESCRIPTION
1027         Takes a BFD as created by <<bfd_create>> and
1028         <<bfd_make_writable>> and converts it into one like as
1029         returned by <<bfd_openr>>.  It does this by writing the
1030         contents out to the memory buffer, then reversing the
1031         direction.
1032
1033         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
1034
1035 bool
1036 bfd_make_readable (bfd *abfd)
1037 {
1038   if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
1039     {
1040       bfd_set_error (bfd_error_invalid_operation);
1041       return false;
1042     }
1043
1044   if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
1045     return false;
1046
1047   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
1048     return false;
1049
1050   abfd->arch_info = &bfd_default_arch_struct;
1051
1052   abfd->where = 0;
1053   abfd->format = bfd_unknown;
1054   abfd->my_archive = NULL;
1055   abfd->origin = 0;
1056   abfd->opened_once = false;
1057   abfd->output_has_begun = false;
1058   abfd->section_count = 0;
1059   abfd->usrdata = NULL;
1060   abfd->cacheable = false;
1061   abfd->flags |= BFD_IN_MEMORY;
1062   abfd->mtime_set = false;
1063
1064   abfd->target_defaulted = true;
1065   abfd->direction = read_direction;
1066   abfd->sections = 0;
1067   abfd->symcount = 0;
1068   abfd->outsymbols = 0;
1069   abfd->tdata.any = 0;
1070   abfd->size = 0;
1071
1072   bfd_section_list_clear (abfd);
1073   bfd_check_format (abfd, bfd_object);
1074
1075   return true;
1076 }
1077
1078 /*
1079    GNU Extension: separate debug-info files
1080
1081    The idea here is that a special section called .gnu_debuglink might be
1082    embedded in a binary file, which indicates that some *other* file
1083    contains the real debugging information. This special section contains a
1084    filename and CRC32 checksum, which we read and resolve to another file,
1085    if it exists.
1086
1087    This facilitates "optional" provision of debugging information, without
1088    having to provide two complete copies of every binary object (with and
1089    without debug symbols).  */
1090
1091 #define GNU_DEBUGLINK           ".gnu_debuglink"
1092 #define GNU_DEBUGALTLINK        ".gnu_debugaltlink"
1093
1094 /*
1095 FUNCTION
1096         bfd_calc_gnu_debuglink_crc32
1097
1098 SYNOPSIS
1099         uint32_t bfd_calc_gnu_debuglink_crc32
1100           (uint32_t crc, const bfd_byte *buf, bfd_size_type len);
1101
1102 DESCRIPTION
1103         Computes a CRC value as used in the .gnu_debuglink section.
1104         Advances the previously computed @var{crc} value by computing
1105         and adding in the crc32 for @var{len} bytes of @var{buf}.
1106
1107         Return the updated CRC32 value.
1108 */
1109
1110 uint32_t
1111 bfd_calc_gnu_debuglink_crc32 (uint32_t crc,
1112                               const bfd_byte *buf,
1113                               bfd_size_type len)
1114 {
1115   static const uint32_t crc32_table[256] =
1116     {
1117       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1118       0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1119       0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1120       0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1121       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1122       0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1123       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1124       0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1125       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1126       0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1127       0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1128       0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1129       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1130       0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1131       0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1132       0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1133       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1134       0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1135       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1136       0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1137       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1138       0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1139       0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1140       0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1141       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1142       0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1143       0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1144       0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1145       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1146       0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1147       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1148       0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1149       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1150       0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1151       0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1152       0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1153       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1154       0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1155       0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1156       0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1157       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1158       0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1159       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1160       0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1161       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1162       0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1163       0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1164       0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1165       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1166       0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1167       0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1168       0x2d02ef8d
1169     };
1170   const bfd_byte *end;
1171
1172   crc = ~crc & 0xffffffff;
1173   for (end = buf + len; buf < end; ++ buf)
1174     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1175   return ~crc & 0xffffffff;
1176 }
1177
1178
1179 /* Extracts the filename and CRC32 value for any separate debug
1180    information file associated with @var{abfd}.
1181
1182    The @var{crc32_out} parameter is an untyped pointer because
1183    this routine is used as a @code{get_func_type} function, but it
1184    is expected to be a uint32_t pointer.
1185
1186    Returns the filename of the associated debug information file,
1187    or NULL if there is no such file.  If the filename was found
1188    then the contents of @var{crc32_out} are updated to hold the
1189    corresponding CRC32 value for the file.
1190
1191    The returned filename is allocated with @code{malloc}; freeing
1192    it is the responsibility of the caller.  */
1193
1194 static char *
1195 bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out)
1196 {
1197   asection *sect;
1198   uint32_t *crc32 = crc32_out;
1199   bfd_byte *contents;
1200   unsigned int crc_offset;
1201   char *name;
1202   bfd_size_type size;
1203
1204   BFD_ASSERT (abfd);
1205   BFD_ASSERT (crc32_out);
1206
1207   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1208
1209   if (sect == NULL || (sect->flags & SEC_HAS_CONTENTS) == 0)
1210     return NULL;
1211
1212   size = bfd_section_size (sect);
1213
1214   /* PR 22794: Make sure that the section has a reasonable size.  */
1215   if (size < 8)
1216     return NULL;
1217
1218   if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1219     return NULL;
1220
1221   /* CRC value is stored after the filename, aligned up to 4 bytes.  */
1222   name = (char *) contents;
1223   /* PR 17597: Avoid reading off the end of the buffer.  */
1224   crc_offset = strnlen (name, size) + 1;
1225   crc_offset = (crc_offset + 3) & ~3;
1226   if (crc_offset + 4 > size)
1227     {
1228       free (name);
1229       return NULL;
1230     }
1231
1232   *crc32 = bfd_get_32 (abfd, contents + crc_offset);
1233   return name;
1234 }
1235
1236
1237 /*
1238 FUNCTION
1239         bfd_get_debug_link_info
1240
1241 SYNOPSIS
1242         char *bfd_get_debug_link_info (bfd *abfd, uint32_t *crc32_out);
1243
1244 DESCRIPTION
1245         Extracts the filename and CRC32 value for any separate debug
1246         information file associated with @var{abfd}.
1247
1248         Returns the filename of the associated debug information file,
1249         or NULL if there is no such file.  If the filename was found
1250         then the contents of @var{crc32_out} are updated to hold the
1251         corresponding CRC32 value for the file.
1252
1253         The returned filename is allocated with @code{malloc}; freeing
1254         it is the responsibility of the caller.
1255 */
1256
1257 char *
1258 bfd_get_debug_link_info (bfd *abfd, uint32_t *crc32_out)
1259 {
1260   return bfd_get_debug_link_info_1 (abfd, crc32_out);
1261 }
1262
1263 /*
1264 FUNCTION
1265         bfd_get_alt_debug_link_info
1266
1267 SYNOPSIS
1268         char *bfd_get_alt_debug_link_info (bfd * abfd,
1269                                            bfd_size_type *buildid_len,
1270                                            bfd_byte **buildid_out);
1271
1272 DESCRIPTION
1273         Fetch the filename and BuildID value for any alternate debuginfo
1274         associated with @var{abfd}.  Return NULL if no such info found,
1275         otherwise return filename and update @var{buildid_len} and
1276         @var{buildid_out}.  The returned filename and build_id are
1277         allocated with @code{malloc}; freeing them is the responsibility
1278         of the caller.
1279 */
1280
1281 char *
1282 bfd_get_alt_debug_link_info (bfd * abfd, bfd_size_type *buildid_len,
1283                              bfd_byte **buildid_out)
1284 {
1285   asection *sect;
1286   bfd_byte *contents;
1287   unsigned int buildid_offset;
1288   char *name;
1289   bfd_size_type size;
1290
1291   BFD_ASSERT (abfd);
1292   BFD_ASSERT (buildid_len);
1293   BFD_ASSERT (buildid_out);
1294
1295   sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK);
1296
1297   if (sect == NULL || (sect->flags & SEC_HAS_CONTENTS) == 0)
1298     return NULL;
1299
1300   size = bfd_section_size (sect);
1301   if (size < 8)
1302     return NULL;
1303
1304   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1305     return NULL;
1306
1307   /* BuildID value is stored after the filename.  */
1308   name = (char *) contents;
1309   buildid_offset = strnlen (name, size) + 1;
1310   if (buildid_offset >= bfd_section_size (sect))
1311     return NULL;
1312
1313   *buildid_len = size - buildid_offset;
1314   *buildid_out = bfd_malloc (*buildid_len);
1315   memcpy (*buildid_out, contents + buildid_offset, *buildid_len);
1316
1317   return name;
1318 }
1319
1320 /* Checks to see if @var{name} is a file and if its contents match
1321    @var{crc32}, which is a pointer to a @code{uint32_t}
1322    containing a CRC32.
1323
1324    The @var{crc32_p} parameter is an untyped pointer because this
1325    routine is used as a @code{check_func_type} function.  */
1326
1327 static bool
1328 separate_debug_file_exists (const char *name, void *crc32_p)
1329 {
1330   unsigned char buffer[8 * 1024];
1331   uint32_t file_crc = 0;
1332   FILE *f;
1333   bfd_size_type count;
1334   uint32_t crc;
1335
1336   BFD_ASSERT (name);
1337   BFD_ASSERT (crc32_p);
1338
1339   crc = *(uint32_t *) crc32_p;
1340
1341   f = _bfd_real_fopen (name, FOPEN_RB);
1342   if (f == NULL)
1343     return false;
1344
1345   while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1346     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1347
1348   fclose (f);
1349
1350   return crc == file_crc;
1351 }
1352
1353 /* Checks to see if @var{name} is a file.  */
1354
1355 static bool
1356 separate_alt_debug_file_exists (const char *name, void *unused ATTRIBUTE_UNUSED)
1357 {
1358   FILE *f;
1359
1360   BFD_ASSERT (name);
1361
1362   f = _bfd_real_fopen (name, FOPEN_RB);
1363   if (f == NULL)
1364     return false;
1365
1366   fclose (f);
1367
1368   return true;
1369 }
1370
1371 /* Searches for a debug information file corresponding to @var{abfd}.
1372
1373    The name of the separate debug info file is returned by the
1374    @var{get} function.  This function scans various fixed locations
1375    in the filesystem, including the file tree rooted at @var{dir}.
1376    If the @var{include_dirs} parameter is true then the directory
1377    components of @var{abfd}'s filename will be included in the
1378    searched locations.
1379
1380    @var{data} is passed unmodified to the @var{get} and @var{check}
1381    functions.  It is generally used to implement build-id-like
1382    matching in the callback functions.
1383
1384    Returns the filename of the first file to be found which
1385    receives a TRUE result from the @var{check} function.
1386    Returns NULL if no valid file could be found.  */
1387
1388 typedef char * (*get_func_type) (bfd *, void *);
1389 typedef bool (*check_func_type) (const char *, void *);
1390
1391 static char *
1392 find_separate_debug_file (bfd *abfd,
1393                           const char *debug_file_directory,
1394                           bool include_dirs,
1395                           get_func_type get_func,
1396                           check_func_type check_func,
1397                           void *func_data)
1398 {
1399   char *base;
1400   char *dir;
1401   char *debugfile;
1402   char *canon_dir;
1403   size_t dirlen;
1404   size_t canon_dirlen;
1405
1406   BFD_ASSERT (abfd);
1407   if (debug_file_directory == NULL)
1408     debug_file_directory = ".";
1409
1410   /* BFD may have been opened from a stream.  */
1411   if (bfd_get_filename (abfd) == NULL)
1412     {
1413       bfd_set_error (bfd_error_invalid_operation);
1414       return NULL;
1415     }
1416
1417   base = get_func (abfd, func_data);
1418
1419   if (base == NULL)
1420     return NULL;
1421
1422   if (base[0] == '\0')
1423     {
1424       free (base);
1425       bfd_set_error (bfd_error_no_debug_section);
1426       return NULL;
1427     }
1428
1429   if (include_dirs)
1430     {
1431       const char *fname = bfd_get_filename (abfd);
1432       for (dirlen = strlen (fname); dirlen > 0; dirlen--)
1433         if (IS_DIR_SEPARATOR (fname[dirlen - 1]))
1434           break;
1435
1436       dir = (char *) bfd_malloc (dirlen + 1);
1437       if (dir == NULL)
1438         {
1439           free (base);
1440           return NULL;
1441         }
1442       memcpy (dir, fname, dirlen);
1443       dir[dirlen] = '\0';
1444     }
1445   else
1446     {
1447       dir = (char *) bfd_malloc (1);
1448       * dir = 0;
1449       dirlen = 0;
1450     }
1451
1452   /* Compute the canonical name of the bfd object with all symbolic links
1453      resolved, for use in the global debugfile directory.  */
1454   canon_dir = lrealpath (bfd_get_filename (abfd));
1455   for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1456     if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1457       break;
1458   canon_dir[canon_dirlen] = '\0';
1459
1460 #ifndef EXTRA_DEBUG_ROOT1
1461 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1462 #endif
1463 #ifndef EXTRA_DEBUG_ROOT2
1464 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1465 #endif
1466
1467   debugfile = (char *)
1468       bfd_malloc (strlen (debug_file_directory) + 1
1469                   + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1470                   + strlen (".debug/")
1471 #ifdef EXTRA_DEBUG_ROOT1
1472                   + strlen (EXTRA_DEBUG_ROOT1)
1473 #endif
1474 #ifdef EXTRA_DEBUG_ROOT2
1475                   + strlen (EXTRA_DEBUG_ROOT2)
1476 #endif
1477                   + strlen (base)
1478                   + 1);
1479   if (debugfile == NULL)
1480     goto found; /* Actually this returns NULL.  */
1481
1482   /* First try in the same directory as the original file.
1483
1484      FIXME: Strictly speaking if we are using the build-id method,
1485      (ie include_dirs == FALSE) then we should only check absolute
1486      paths, not relative ones like this one (and the next one).
1487      The check is left in however as this allows the binutils
1488      testsuite to exercise this feature without having to install
1489      a file into the root filesystem.  (See binutils/testsuite/
1490      binutils-all/objdump.exp for the test).  */
1491   sprintf (debugfile, "%s%s", dir, base);
1492   if (check_func (debugfile, func_data))
1493     goto found;
1494
1495   /* Then try in a subdirectory called .debug.  */
1496   sprintf (debugfile, "%s.debug/%s", dir, base);
1497   if (check_func (debugfile, func_data))
1498     goto found;
1499
1500 #ifdef EXTRA_DEBUG_ROOT1
1501   /* Try the first extra debug file root.  */
1502   sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT1,
1503            include_dirs ? canon_dir : "/", base);
1504   if (check_func (debugfile, func_data))
1505     goto found;
1506 #endif
1507
1508 #ifdef EXTRA_DEBUG_ROOT2
1509   /* Try the second extra debug file root.  */
1510   sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT2,
1511            include_dirs ? canon_dir : "/", base);
1512   if (check_func (debugfile, func_data))
1513     goto found;
1514 #endif
1515
1516   /* Then try in the global debugfile directory.  */
1517   strcpy (debugfile, debug_file_directory);
1518   dirlen = strlen (debug_file_directory) - 1;
1519   if (include_dirs)
1520     {
1521       if (dirlen > 0
1522           && debug_file_directory[dirlen] != '/'
1523           && canon_dir[0] != '/')
1524         strcat (debugfile, "/");
1525       strcat (debugfile, canon_dir);
1526     }
1527   else
1528     {
1529       if (dirlen > 0 && debug_file_directory[dirlen] != '/')
1530         strcat (debugfile, "/");
1531     }
1532   strcat (debugfile, base);
1533
1534   if (check_func (debugfile, func_data))
1535     goto found;
1536
1537   /* Failed to find the file.  */
1538   free (debugfile);
1539   debugfile = NULL;
1540
1541  found:
1542   free (base);
1543   free (dir);
1544   free (canon_dir);
1545   return debugfile;
1546 }
1547
1548 /*
1549 FUNCTION
1550         bfd_follow_gnu_debuglink
1551
1552 SYNOPSIS
1553         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1554
1555 DESCRIPTION
1556         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1557         section is found, it examines the section for the name and checksum
1558         of a '.debug' file containing auxiliary debugging information.  It
1559         then searches the filesystem for this .debug file in some standard
1560         locations, including the directory tree rooted at @var{dir}, and if
1561         found returns the full filename.
1562
1563         If @var{dir} is NULL, the search will take place starting at
1564         the current directory.
1565
1566         Returns <<NULL>> on any errors or failure to locate the .debug
1567         file, otherwise a pointer to a heap-allocated string
1568         containing the filename.  The caller is responsible for
1569         freeing this string.
1570 */
1571
1572 char *
1573 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1574 {
1575   uint32_t crc32;
1576
1577   return find_separate_debug_file (abfd, dir, true,
1578                                    bfd_get_debug_link_info_1,
1579                                    separate_debug_file_exists, &crc32);
1580 }
1581
1582 /* Helper for bfd_follow_gnu_debugaltlink.  It just returns the name
1583    of the separate debug file.  */
1584
1585 static char *
1586 get_alt_debug_link_info_shim (bfd * abfd, void *unused ATTRIBUTE_UNUSED)
1587 {
1588   bfd_size_type len;
1589   bfd_byte *buildid = NULL;
1590   char *result = bfd_get_alt_debug_link_info (abfd, &len, &buildid);
1591
1592   free (buildid);
1593
1594   return result;
1595 }
1596
1597 /*
1598 FUNCTION
1599         bfd_follow_gnu_debugaltlink
1600
1601 SYNOPSIS
1602         char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1603
1604 DESCRIPTION
1605         Takes a BFD and searches it for a .gnu_debugaltlink section.  If this
1606         section is found, it examines the section for the name of a file
1607         containing auxiliary debugging information.  It then searches the
1608         filesystem for this file in a set of standard locations, including
1609         the directory tree rooted at @var{dir}, and if found returns the
1610         full filename.
1611
1612         If @var{dir} is NULL, the search will take place starting at
1613         the current directory.
1614
1615         Returns <<NULL>> on any errors or failure to locate the debug
1616         file, otherwise a pointer to a heap-allocated string
1617         containing the filename.  The caller is responsible for
1618         freeing this string.
1619 */
1620
1621 char *
1622 bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir)
1623 {
1624   return find_separate_debug_file (abfd, dir, true,
1625                                    get_alt_debug_link_info_shim,
1626                                    separate_alt_debug_file_exists,
1627                                    NULL);
1628 }
1629
1630 /*
1631 FUNCTION
1632         bfd_create_gnu_debuglink_section
1633
1634 SYNOPSIS
1635         struct bfd_section *bfd_create_gnu_debuglink_section
1636           (bfd *abfd, const char *filename);
1637
1638 DESCRIPTION
1639         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The
1640         section is sized to be big enough to contain a link to the specified
1641         @var{filename}.
1642
1643         A pointer to the new section is returned if all is ok.  Otherwise
1644         <<NULL>> is returned and bfd_error is set.
1645 */
1646
1647 asection *
1648 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1649 {
1650   asection *sect;
1651   bfd_size_type debuglink_size;
1652   flagword flags;
1653
1654   if (abfd == NULL || filename == NULL)
1655     {
1656       bfd_set_error (bfd_error_invalid_operation);
1657       return NULL;
1658     }
1659
1660   /* Strip off any path components in filename.  */
1661   filename = lbasename (filename);
1662
1663   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1664   if (sect)
1665     {
1666       /* Section already exists.  */
1667       bfd_set_error (bfd_error_invalid_operation);
1668       return NULL;
1669     }
1670
1671   flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1672   sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1673   if (sect == NULL)
1674     return NULL;
1675
1676   /* Compute the size of the section.  Allow for the CRC after the filename,
1677      and padding so that it will start on a 4-byte boundary.  */
1678   debuglink_size = strlen (filename) + 1;
1679   debuglink_size += 3;
1680   debuglink_size &= ~3;
1681   debuglink_size += 4;
1682
1683   if (!bfd_set_section_size (sect, debuglink_size))
1684     /* XXX Should we delete the section from the bfd ?  */
1685     return NULL;
1686
1687   /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1688      Note - despite the name of the function being called, we are
1689      setting an alignment power, not a byte alignment value.  */
1690   bfd_set_section_alignment (sect, 2);
1691
1692   return sect;
1693 }
1694
1695
1696 /*
1697 FUNCTION
1698         bfd_fill_in_gnu_debuglink_section
1699
1700 SYNOPSIS
1701         bool bfd_fill_in_gnu_debuglink_section
1702           (bfd *abfd, struct bfd_section *sect, const char *filename);
1703
1704 DESCRIPTION
1705         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1706         and fills in the contents of the section to contain a link to the
1707         specified @var{filename}.  The filename should be absolute or
1708         relative to the current directory.
1709
1710         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1711         and bfd_error is set.
1712 */
1713
1714 bool
1715 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1716                                    struct bfd_section *sect,
1717                                    const char *filename)
1718 {
1719   bfd_size_type debuglink_size;
1720   uint32_t crc32;
1721   char * contents;
1722   bfd_size_type crc_offset;
1723   FILE * handle;
1724   unsigned char buffer[8 * 1024];
1725   size_t count;
1726   size_t filelen;
1727
1728   if (abfd == NULL || sect == NULL || filename == NULL)
1729     {
1730       bfd_set_error (bfd_error_invalid_operation);
1731       return false;
1732     }
1733
1734   /* Open the linked file so that we can compute a CRC.  */
1735   handle = _bfd_real_fopen (filename, FOPEN_RB);
1736   if (handle == NULL)
1737     {
1738       bfd_set_error (bfd_error_system_call);
1739       return false;
1740     }
1741
1742   crc32 = 0;
1743   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1744     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1745   fclose (handle);
1746
1747   /* Strip off any path components in filename,
1748      now that we no longer need them.  */
1749   filename = lbasename (filename);
1750
1751   filelen = strlen (filename);
1752   debuglink_size = filelen + 1;
1753   debuglink_size += 3;
1754   debuglink_size &= ~3;
1755   debuglink_size += 4;
1756
1757   contents = (char *) bfd_malloc (debuglink_size);
1758   if (contents == NULL)
1759     {
1760       /* XXX Should we delete the section from the bfd ?  */
1761       return false;
1762     }
1763
1764   crc_offset = debuglink_size - 4;
1765   memcpy (contents, filename, filelen);
1766   memset (contents + filelen, 0, crc_offset - filelen);
1767
1768   bfd_put_32 (abfd, crc32, contents + crc_offset);
1769
1770   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1771     {
1772       /* XXX Should we delete the section from the bfd ?  */
1773       free (contents);
1774       return false;
1775     }
1776
1777   return true;
1778 }
1779
1780 /* Finds the build-id associated with @var{abfd}.  If the build-id is
1781    extracted from the note section then a build-id structure is built
1782    for it, using memory allocated to @var{abfd}, and this is then
1783    attached to the @var{abfd}.
1784
1785    Returns a pointer to the build-id structure if a build-id could be
1786    found.  If no build-id is found NULL is returned and error code is
1787    set.  */
1788
1789 static struct bfd_build_id *
1790 get_build_id (bfd *abfd)
1791 {
1792   struct bfd_build_id *build_id;
1793   Elf_Internal_Note inote;
1794   Elf_External_Note *enote;
1795   bfd_byte *contents;
1796   asection *sect;
1797   bfd_size_type size;
1798
1799   BFD_ASSERT (abfd);
1800
1801   if (abfd->build_id && abfd->build_id->size > 0)
1802     /* Save some time by using the already computed build-id.  */
1803     return (struct bfd_build_id *) abfd->build_id;
1804
1805   sect = bfd_get_section_by_name (abfd, ".note.gnu.build-id");
1806   if (sect == NULL
1807       || (sect->flags & SEC_HAS_CONTENTS) == 0)
1808     {
1809       bfd_set_error (bfd_error_no_debug_section);
1810       return NULL;
1811     }
1812
1813   size = bfd_section_size (sect);
1814   /* FIXME: Should we support smaller build-id notes ?  */
1815   if (size < 0x24)
1816     {
1817       bfd_set_error (bfd_error_invalid_operation);
1818       return NULL;
1819     }
1820
1821   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1822     return NULL;
1823
1824   /* FIXME: Paranoia - allow for compressed build-id sections.
1825      Maybe we should complain if this size is different from
1826      the one obtained above...  */
1827   size = bfd_section_size (sect);
1828   if (size < sizeof (Elf_External_Note))
1829     {
1830       bfd_set_error (bfd_error_invalid_operation);
1831       free (contents);
1832       return NULL;
1833     }
1834
1835   enote = (Elf_External_Note *) contents;
1836   inote.type = H_GET_32 (abfd, enote->type);
1837   inote.namesz = H_GET_32 (abfd, enote->namesz);
1838   inote.namedata = enote->name;
1839   inote.descsz = H_GET_32 (abfd, enote->descsz);
1840   inote.descdata = inote.namedata + BFD_ALIGN (inote.namesz, 4);
1841   /* FIXME: Should we check for extra notes in this section ?  */
1842
1843   if (inote.descsz <= 0
1844       || inote.type != NT_GNU_BUILD_ID
1845       || inote.namesz != 4 /* sizeof "GNU"  */
1846       || !startswith (inote.namedata, "GNU")
1847       || inote.descsz > 0x7ffffffe
1848       || size < (12 + BFD_ALIGN (inote.namesz, 4) + inote.descsz))
1849     {
1850       free (contents);
1851       bfd_set_error (bfd_error_invalid_operation);
1852       return NULL;
1853     }
1854
1855   build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) + inote.descsz);
1856   if (build_id == NULL)
1857     {
1858       free (contents);
1859       return NULL;
1860     }
1861
1862   build_id->size = inote.descsz;
1863   memcpy (build_id->data, inote.descdata, inote.descsz);
1864   abfd->build_id = build_id;
1865   free (contents);
1866
1867   return build_id;
1868 }
1869
1870 /* Searches @var{abfd} for a build-id, and then constructs a pathname
1871    from it.  The path is computed as .build-id/NN/NN+NN.debug where
1872    NNNN+NN is the build-id value as a hexadecimal string.
1873
1874    Returns the constructed filename or NULL upon error.  It is the
1875    caller's responsibility to free the memory used to hold the
1876    filename.  If a filename is returned then the @var{build_id_out_p}
1877    parameter (which points to a @code{struct bfd_build_id} pointer) is
1878    set to a pointer to the build_id structure.  */
1879
1880 static char *
1881 get_build_id_name (bfd *abfd, void *build_id_out_p)
1882 {
1883   struct bfd_build_id **build_id_out = build_id_out_p;
1884   struct bfd_build_id *build_id;
1885   char *name;
1886   char *n;
1887   bfd_size_type s;
1888   bfd_byte *d;
1889
1890   if (abfd == NULL || bfd_get_filename (abfd) == NULL || build_id_out == NULL)
1891     {
1892       bfd_set_error (bfd_error_invalid_operation);
1893       return NULL;
1894     }
1895
1896   build_id = get_build_id (abfd);
1897   if (build_id == NULL)
1898     return NULL;
1899
1900   /* Compute the debug pathname corresponding to the build-id.  */
1901   name = bfd_malloc (strlen (".build-id/") + build_id->size * 2 + 2 + strlen (".debug"));
1902   if (name == NULL)
1903     {
1904       bfd_set_error (bfd_error_no_memory);
1905       return NULL;
1906     }
1907   n = name;
1908   d = build_id->data;
1909   s = build_id->size;
1910
1911   n += sprintf (n, ".build-id/");
1912   n += sprintf (n, "%02x", (unsigned) *d++); s--;
1913   n += sprintf (n, "/");
1914   while (s--)
1915     n += sprintf (n, "%02x", (unsigned) *d++);
1916   n += sprintf (n, ".debug");
1917
1918   *build_id_out = build_id;
1919   return name;
1920 }
1921
1922 /* Checks to see if @var{name} is a readable file and if its build-id
1923    matches @var{buildid}.
1924
1925    Returns TRUE if the file exists, is readable, and contains a
1926    build-id which matches the build-id pointed at by @var{build_id_p}
1927    (which is really a @code{struct bfd_build_id **}).  */
1928
1929 static bool
1930 check_build_id_file (const char *name, void *buildid_p)
1931 {
1932   struct bfd_build_id *orig_build_id;
1933   struct bfd_build_id *build_id;
1934   bfd * file;
1935   bool result;
1936
1937   BFD_ASSERT (name);
1938   BFD_ASSERT (buildid_p);
1939
1940   file = bfd_openr (name, NULL);
1941   if (file == NULL)
1942     return false;
1943
1944   /* If the file is an archive, process all of its elements.  */
1945   if (! bfd_check_format (file, bfd_object))
1946     {
1947       bfd_close (file);
1948       return false;
1949     }
1950
1951   build_id = get_build_id (file);
1952   if (build_id == NULL)
1953     {
1954       bfd_close (file);
1955       return false;
1956     }
1957
1958   orig_build_id = *(struct bfd_build_id **) buildid_p;
1959
1960   result = build_id->size == orig_build_id->size
1961     && memcmp (build_id->data, orig_build_id->data, build_id->size) == 0;
1962
1963   (void) bfd_close (file);
1964
1965   return result;
1966 }
1967
1968 /*
1969 FUNCTION
1970         bfd_follow_build_id_debuglink
1971
1972 SYNOPSIS
1973         char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
1974
1975 DESCRIPTION
1976         Takes @var{abfd} and searches it for a .note.gnu.build-id section.
1977         If this section is found, it extracts the value of the NT_GNU_BUILD_ID
1978         note, which should be a hexadecimal value @var{NNNN+NN} (for
1979         32+ hex digits).  It then searches the filesystem for a file named
1980         @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
1981         including the directory tree rooted at @var{dir}.  The filename
1982         of the first matching file to be found is returned.  A matching
1983         file should contain a .note.gnu.build-id section with the same
1984         @var{NNNN+NN} note as @var{abfd}, although this check is currently
1985         not implemented.
1986
1987         If @var{dir} is NULL, the search will take place starting at
1988         the current directory.
1989
1990         Returns <<NULL>> on any errors or failure to locate the debug
1991         file, otherwise a pointer to a heap-allocated string
1992         containing the filename.  The caller is responsible for
1993         freeing this string.
1994 */
1995
1996 char *
1997 bfd_follow_build_id_debuglink (bfd *abfd, const char *dir)
1998 {
1999   struct bfd_build_id *build_id;
2000
2001   return find_separate_debug_file (abfd, dir, false,
2002                                    get_build_id_name,
2003                                    check_build_id_file, &build_id);
2004 }
2005
2006 /*
2007 FUNCTION
2008         bfd_set_filename
2009
2010 SYNOPSIS
2011         const char *bfd_set_filename (bfd *abfd, const char *filename);
2012
2013 DESCRIPTION
2014         Set the filename of @var{abfd}, copying the FILENAME parameter to
2015         bfd_alloc'd memory owned by @var{abfd}.  Returns a pointer the
2016         newly allocated name, or NULL if the allocation failed.
2017 */
2018
2019 const char *
2020 bfd_set_filename (bfd *abfd, const char *filename)
2021 {
2022   size_t len = strlen (filename) + 1;
2023   char *n = bfd_alloc (abfd, len);
2024
2025   if (n == NULL)
2026     return NULL;
2027
2028   if (abfd->filename != NULL)
2029     {
2030       /* PR 29389.  If we attempt to rename a file that has been closed due
2031          to caching, then we will not be able to reopen it later on.  */
2032       if (abfd->iostream == NULL && (abfd->flags & BFD_CLOSED_BY_CACHE))
2033         {
2034           bfd_set_error (bfd_error_invalid_operation);
2035           return NULL;
2036         }
2037
2038       /* Similarly if we attempt to close a renamed file because the
2039          cache is now full, we will not be able to reopen it later on.  */
2040       if (abfd->iostream != NULL)
2041         abfd->cacheable = 0;
2042     }
2043
2044   memcpy (n, filename, len);
2045   abfd->filename = n;
2046
2047   return n;
2048 }