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 (ret && abfd->iovec != NULL)
 924     {
 925       ret = abfd->iovec->bclose (abfd) == 0;
 926
 927       if (ret)
 928         _maybe_make_executable (abfd);
 929     }
 930
 931   _bfd_delete_bfd (abfd);
 932   free (_bfd_error_buf);
 933   _bfd_error_buf = NULL;
 934
 935   return ret;
 936 }
 937
 938 /*
 939 FUNCTION
 940         bfd_create
 941
 942 SYNOPSIS
 943         bfd *bfd_create (const char *filename, bfd *templ);
 944
 945 DESCRIPTION
 946         Create a new BFD in the manner of <<bfd_openw>>, but without
 947         opening a file. The new BFD takes the target from the target
 948         used by @var{templ}. The format is always set to <<bfd_object>>.
 949
 950         A copy of the @var{filename} argument is stored in the newly created
 951         BFD.  It can be accessed via the bfd_get_filename() macro.
 952 */
 953
 954 bfd *
 955 bfd_create (const char *filename, bfd *templ)
 956 {
 957   bfd *nbfd;
 958
 959   nbfd = _bfd_new_bfd ();
 960   if (nbfd == NULL)
 961     return NULL;
 962   /* PR 11983: Do not cache the original filename, but
 963      rather make a copy - the original might go away.  */
 964   if (!bfd_set_filename (nbfd, filename))
 965     {
 966       _bfd_delete_bfd (nbfd);
 967       return NULL;
 968     }
 969   if (templ)
 970     nbfd->xvec = templ->xvec;
 971   nbfd->direction = no_direction;
 972   bfd_set_format (nbfd, bfd_object);
 973
 974   return nbfd;
 975 }
 976
 977 /*
 978 FUNCTION
 979         bfd_make_writable
 980
 981 SYNOPSIS
 982         bool bfd_make_writable (bfd *abfd);
 983
 984 DESCRIPTION
 985         Takes a BFD as created by <<bfd_create>> and converts it
 986         into one like as returned by <<bfd_openw>>.  It does this
 987         by converting the BFD to BFD_IN_MEMORY.  It's assumed that
 988         you will call <<bfd_make_readable>> on this bfd later.
 989
 990         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 991 */
 992
 993 bool
 994 bfd_make_writable (bfd *abfd)
 995 {
 996   struct bfd_in_memory *bim;
 997
 998   if (abfd->direction != no_direction)
 999     {
1000       bfd_set_error (bfd_error_invalid_operation);
1001       return false;
1002     }
1003
1004   bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
1005   if (bim == NULL)
1006     return false;       /* bfd_error already set.  */
1007   abfd->iostream = bim;
1008   /* bfd_bwrite will grow these as needed.  */
1009   bim->size = 0;
1010   bim->buffer = 0;
1011
1012   abfd->flags |= BFD_IN_MEMORY;
1013   abfd->iovec = &_bfd_memory_iovec;
1014   abfd->origin = 0;
1015   abfd->direction = write_direction;
1016   abfd->where = 0;
1017
1018   return true;
1019 }
1020
1021 /*
1022 FUNCTION
1023         bfd_make_readable
1024
1025 SYNOPSIS
1026         bool bfd_make_readable (bfd *abfd);
1027
1028 DESCRIPTION
1029         Takes a BFD as created by <<bfd_create>> and
1030         <<bfd_make_writable>> and converts it into one like as
1031         returned by <<bfd_openr>>.  It does this by writing the
1032         contents out to the memory buffer, then reversing the
1033         direction.
1034
1035         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
1036
1037 bool
1038 bfd_make_readable (bfd *abfd)
1039 {
1040   if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
1041     {
1042       bfd_set_error (bfd_error_invalid_operation);
1043       return false;
1044     }
1045
1046   if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
1047     return false;
1048
1049   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
1050     return false;
1051
1052   abfd->arch_info = &bfd_default_arch_struct;
1053
1054   abfd->where = 0;
1055   abfd->format = bfd_unknown;
1056   abfd->my_archive = NULL;
1057   abfd->origin = 0;
1058   abfd->opened_once = false;
1059   abfd->output_has_begun = false;
1060   abfd->section_count = 0;
1061   abfd->usrdata = NULL;
1062   abfd->cacheable = false;
1063   abfd->flags |= BFD_IN_MEMORY;
1064   abfd->mtime_set = false;
1065
1066   abfd->target_defaulted = true;
1067   abfd->direction = read_direction;
1068   abfd->sections = 0;
1069   abfd->symcount = 0;
1070   abfd->outsymbols = 0;
1071   abfd->tdata.any = 0;
1072   abfd->size = 0;
1073
1074   bfd_section_list_clear (abfd);
1075   bfd_check_format (abfd, bfd_object);
1076
1077   return true;
1078 }
1079
1080 /*
1081    GNU Extension: separate debug-info files
1082
1083    The idea here is that a special section called .gnu_debuglink might be
1084    embedded in a binary file, which indicates that some *other* file
1085    contains the real debugging information. This special section contains a
1086    filename and CRC32 checksum, which we read and resolve to another file,
1087    if it exists.
1088
1089    This facilitates "optional" provision of debugging information, without
1090    having to provide two complete copies of every binary object (with and
1091    without debug symbols).  */
1092
1093 #define GNU_DEBUGLINK           ".gnu_debuglink"
1094 #define GNU_DEBUGALTLINK        ".gnu_debugaltlink"
1095
1096 /*
1097 FUNCTION
1098         bfd_calc_gnu_debuglink_crc32
1099
1100 SYNOPSIS
1101         uint32_t bfd_calc_gnu_debuglink_crc32
1102           (uint32_t crc, const bfd_byte *buf, bfd_size_type len);
1103
1104 DESCRIPTION
1105         Computes a CRC value as used in the .gnu_debuglink section.
1106         Advances the previously computed @var{crc} value by computing
1107         and adding in the crc32 for @var{len} bytes of @var{buf}.
1108
1109         Return the updated CRC32 value.
1110 */
1111
1112 uint32_t
1113 bfd_calc_gnu_debuglink_crc32 (uint32_t crc,
1114                               const bfd_byte *buf,
1115                               bfd_size_type len)
1116 {
1117   static const uint32_t crc32_table[256] =
1118     {
1119       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1120       0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1121       0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1122       0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1123       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1124       0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1125       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1126       0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1127       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1128       0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1129       0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1130       0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1131       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1132       0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1133       0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1134       0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1135       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1136       0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1137       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1138       0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1139       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1140       0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1141       0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1142       0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1143       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1144       0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1145       0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1146       0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1147       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1148       0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1149       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1150       0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1151       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1152       0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1153       0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1154       0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1155       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1156       0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1157       0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1158       0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1159       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1160       0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1161       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1162       0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1163       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1164       0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1165       0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1166       0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1167       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1168       0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1169       0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1170       0x2d02ef8d
1171     };
1172   const bfd_byte *end;
1173
1174   crc = ~crc & 0xffffffff;
1175   for (end = buf + len; buf < end; ++ buf)
1176     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1177   return ~crc & 0xffffffff;
1178 }
1179
1180
1181 /* Extracts the filename and CRC32 value for any separate debug
1182    information file associated with @var{abfd}.
1183
1184    The @var{crc32_out} parameter is an untyped pointer because
1185    this routine is used as a @code{get_func_type} function, but it
1186    is expected to be a uint32_t pointer.
1187
1188    Returns the filename of the associated debug information file,
1189    or NULL if there is no such file.  If the filename was found
1190    then the contents of @var{crc32_out} are updated to hold the
1191    corresponding CRC32 value for the file.
1192
1193    The returned filename is allocated with @code{malloc}; freeing
1194    it is the responsibility of the caller.  */
1195
1196 static char *
1197 bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out)
1198 {
1199   asection *sect;
1200   uint32_t *crc32 = crc32_out;
1201   bfd_byte *contents;
1202   unsigned int crc_offset;
1203   char *name;
1204   bfd_size_type size;
1205
1206   BFD_ASSERT (abfd);
1207   BFD_ASSERT (crc32_out);
1208
1209   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1210
1211   if (sect == NULL || (sect->flags & SEC_HAS_CONTENTS) == 0)
1212     return NULL;
1213
1214   size = bfd_section_size (sect);
1215
1216   /* PR 22794: Make sure that the section has a reasonable size.  */
1217   if (size < 8)
1218     return NULL;
1219
1220   if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1221     return NULL;
1222
1223   /* CRC value is stored after the filename, aligned up to 4 bytes.  */
1224   name = (char *) contents;
1225   /* PR 17597: Avoid reading off the end of the buffer.  */
1226   crc_offset = strnlen (name, size) + 1;
1227   crc_offset = (crc_offset + 3) & ~3;
1228   if (crc_offset + 4 > size)
1229     {
1230       free (name);
1231       return NULL;
1232     }
1233
1234   *crc32 = bfd_get_32 (abfd, contents + crc_offset);
1235   return name;
1236 }
1237
1238
1239 /*
1240 FUNCTION
1241         bfd_get_debug_link_info
1242
1243 SYNOPSIS
1244         char *bfd_get_debug_link_info (bfd *abfd, uint32_t *crc32_out);
1245
1246 DESCRIPTION
1247         Extracts the filename and CRC32 value for any separate debug
1248         information file associated with @var{abfd}.
1249
1250         Returns the filename of the associated debug information file,
1251         or NULL if there is no such file.  If the filename was found
1252         then the contents of @var{crc32_out} are updated to hold the
1253         corresponding CRC32 value for the file.
1254
1255         The returned filename is allocated with @code{malloc}; freeing
1256         it is the responsibility of the caller.
1257 */
1258
1259 char *
1260 bfd_get_debug_link_info (bfd *abfd, uint32_t *crc32_out)
1261 {
1262   return bfd_get_debug_link_info_1 (abfd, crc32_out);
1263 }
1264
1265 /*
1266 FUNCTION
1267         bfd_get_alt_debug_link_info
1268
1269 SYNOPSIS
1270         char *bfd_get_alt_debug_link_info (bfd * abfd,
1271                                            bfd_size_type *buildid_len,
1272                                            bfd_byte **buildid_out);
1273
1274 DESCRIPTION
1275         Fetch the filename and BuildID value for any alternate debuginfo
1276         associated with @var{abfd}.  Return NULL if no such info found,
1277         otherwise return filename and update @var{buildid_len} and
1278         @var{buildid_out}.  The returned filename and build_id are
1279         allocated with @code{malloc}; freeing them is the responsibility
1280         of the caller.
1281 */
1282
1283 char *
1284 bfd_get_alt_debug_link_info (bfd * abfd, bfd_size_type *buildid_len,
1285                              bfd_byte **buildid_out)
1286 {
1287   asection *sect;
1288   bfd_byte *contents;
1289   unsigned int buildid_offset;
1290   char *name;
1291   bfd_size_type size;
1292
1293   BFD_ASSERT (abfd);
1294   BFD_ASSERT (buildid_len);
1295   BFD_ASSERT (buildid_out);
1296
1297   sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK);
1298
1299   if (sect == NULL || (sect->flags & SEC_HAS_CONTENTS) == 0)
1300     return NULL;
1301
1302   size = bfd_section_size (sect);
1303   if (size < 8)
1304     return NULL;
1305
1306   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1307     return NULL;
1308
1309   /* BuildID value is stored after the filename.  */
1310   name = (char *) contents;
1311   buildid_offset = strnlen (name, size) + 1;
1312   if (buildid_offset >= bfd_section_size (sect))
1313     return NULL;
1314
1315   *buildid_len = size - buildid_offset;
1316   *buildid_out = bfd_malloc (*buildid_len);
1317   memcpy (*buildid_out, contents + buildid_offset, *buildid_len);
1318
1319   return name;
1320 }
1321
1322 /* Checks to see if @var{name} is a file and if its contents match
1323    @var{crc32}, which is a pointer to a @code{uint32_t}
1324    containing a CRC32.
1325
1326    The @var{crc32_p} parameter is an untyped pointer because this
1327    routine is used as a @code{check_func_type} function.  */
1328
1329 static bool
1330 separate_debug_file_exists (const char *name, void *crc32_p)
1331 {
1332   unsigned char buffer[8 * 1024];
1333   uint32_t file_crc = 0;
1334   FILE *f;
1335   bfd_size_type count;
1336   uint32_t crc;
1337
1338   BFD_ASSERT (name);
1339   BFD_ASSERT (crc32_p);
1340
1341   crc = *(uint32_t *) crc32_p;
1342
1343   f = _bfd_real_fopen (name, FOPEN_RB);
1344   if (f == NULL)
1345     return false;
1346
1347   while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1348     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1349
1350   fclose (f);
1351
1352   return crc == file_crc;
1353 }
1354
1355 /* Checks to see if @var{name} is a file.  */
1356
1357 static bool
1358 separate_alt_debug_file_exists (const char *name, void *unused ATTRIBUTE_UNUSED)
1359 {
1360   FILE *f;
1361
1362   BFD_ASSERT (name);
1363
1364   f = _bfd_real_fopen (name, FOPEN_RB);
1365   if (f == NULL)
1366     return false;
1367
1368   fclose (f);
1369
1370   return true;
1371 }
1372
1373 /* Searches for a debug information file corresponding to @var{abfd}.
1374
1375    The name of the separate debug info file is returned by the
1376    @var{get} function.  This function scans various fixed locations
1377    in the filesystem, including the file tree rooted at @var{dir}.
1378    If the @var{include_dirs} parameter is true then the directory
1379    components of @var{abfd}'s filename will be included in the
1380    searched locations.
1381
1382    @var{data} is passed unmodified to the @var{get} and @var{check}
1383    functions.  It is generally used to implement build-id-like
1384    matching in the callback functions.
1385
1386    Returns the filename of the first file to be found which
1387    receives a TRUE result from the @var{check} function.
1388    Returns NULL if no valid file could be found.  */
1389
1390 typedef char * (*get_func_type) (bfd *, void *);
1391 typedef bool (*check_func_type) (const char *, void *);
1392
1393 static char *
1394 find_separate_debug_file (bfd *abfd,
1395                           const char *debug_file_directory,
1396                           bool include_dirs,
1397                           get_func_type get_func,
1398                           check_func_type check_func,
1399                           void *func_data)
1400 {
1401   char *base;
1402   char *dir;
1403   char *debugfile;
1404   char *canon_dir;
1405   size_t dirlen;
1406   size_t canon_dirlen;
1407
1408   BFD_ASSERT (abfd);
1409   if (debug_file_directory == NULL)
1410     debug_file_directory = ".";
1411
1412   /* BFD may have been opened from a stream.  */
1413   if (bfd_get_filename (abfd) == NULL)
1414     {
1415       bfd_set_error (bfd_error_invalid_operation);
1416       return NULL;
1417     }
1418
1419   base = get_func (abfd, func_data);
1420
1421   if (base == NULL)
1422     return NULL;
1423
1424   if (base[0] == '\0')
1425     {
1426       free (base);
1427       bfd_set_error (bfd_error_no_debug_section);
1428       return NULL;
1429     }
1430
1431   if (include_dirs)
1432     {
1433       const char *fname = bfd_get_filename (abfd);
1434       for (dirlen = strlen (fname); dirlen > 0; dirlen--)
1435         if (IS_DIR_SEPARATOR (fname[dirlen - 1]))
1436           break;
1437
1438       dir = (char *) bfd_malloc (dirlen + 1);
1439       if (dir == NULL)
1440         {
1441           free (base);
1442           return NULL;
1443         }
1444       memcpy (dir, fname, dirlen);
1445       dir[dirlen] = '\0';
1446     }
1447   else
1448     {
1449       dir = (char *) bfd_malloc (1);
1450       * dir = 0;
1451       dirlen = 0;
1452     }
1453
1454   /* Compute the canonical name of the bfd object with all symbolic links
1455      resolved, for use in the global debugfile directory.  */
1456   canon_dir = lrealpath (bfd_get_filename (abfd));
1457   for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1458     if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1459       break;
1460   canon_dir[canon_dirlen] = '\0';
1461
1462 #ifndef EXTRA_DEBUG_ROOT1
1463 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1464 #endif
1465 #ifndef EXTRA_DEBUG_ROOT2
1466 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1467 #endif
1468
1469   debugfile = (char *)
1470       bfd_malloc (strlen (debug_file_directory) + 1
1471                   + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1472                   + strlen (".debug/")
1473 #ifdef EXTRA_DEBUG_ROOT1
1474                   + strlen (EXTRA_DEBUG_ROOT1)
1475 #endif
1476 #ifdef EXTRA_DEBUG_ROOT2
1477                   + strlen (EXTRA_DEBUG_ROOT2)
1478 #endif
1479                   + strlen (base)
1480                   + 1);
1481   if (debugfile == NULL)
1482     goto found; /* Actually this returns NULL.  */
1483
1484   /* First try in the same directory as the original file.
1485
1486      FIXME: Strictly speaking if we are using the build-id method,
1487      (ie include_dirs == FALSE) then we should only check absolute
1488      paths, not relative ones like this one (and the next one).
1489      The check is left in however as this allows the binutils
1490      testsuite to exercise this feature without having to install
1491      a file into the root filesystem.  (See binutils/testsuite/
1492      binutils-all/objdump.exp for the test).  */
1493   sprintf (debugfile, "%s%s", dir, base);
1494   if (check_func (debugfile, func_data))
1495     goto found;
1496
1497   /* Then try in a subdirectory called .debug.  */
1498   sprintf (debugfile, "%s.debug/%s", dir, base);
1499   if (check_func (debugfile, func_data))
1500     goto found;
1501
1502 #ifdef EXTRA_DEBUG_ROOT1
1503   /* Try the first extra debug file root.  */
1504   sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT1,
1505            include_dirs ? canon_dir : "/", base);
1506   if (check_func (debugfile, func_data))
1507     goto found;
1508 #endif
1509
1510 #ifdef EXTRA_DEBUG_ROOT2
1511   /* Try the second extra debug file root.  */
1512   sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT2,
1513            include_dirs ? canon_dir : "/", base);
1514   if (check_func (debugfile, func_data))
1515     goto found;
1516 #endif
1517
1518   /* Then try in the global debugfile directory.  */
1519   strcpy (debugfile, debug_file_directory);
1520   dirlen = strlen (debug_file_directory) - 1;
1521   if (include_dirs)
1522     {
1523       if (dirlen > 0
1524           && debug_file_directory[dirlen] != '/'
1525           && canon_dir[0] != '/')
1526         strcat (debugfile, "/");
1527       strcat (debugfile, canon_dir);
1528     }
1529   else
1530     {
1531       if (dirlen > 0 && debug_file_directory[dirlen] != '/')
1532         strcat (debugfile, "/");
1533     }
1534   strcat (debugfile, base);
1535
1536   if (check_func (debugfile, func_data))
1537     goto found;
1538
1539   /* Failed to find the file.  */
1540   free (debugfile);
1541   debugfile = NULL;
1542
1543  found:
1544   free (base);
1545   free (dir);
1546   free (canon_dir);
1547   return debugfile;
1548 }
1549
1550 /*
1551 FUNCTION
1552         bfd_follow_gnu_debuglink
1553
1554 SYNOPSIS
1555         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1556
1557 DESCRIPTION
1558         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1559         section is found, it examines the section for the name and checksum
1560         of a '.debug' file containing auxiliary debugging information.  It
1561         then searches the filesystem for this .debug file in some standard
1562         locations, including the directory tree rooted at @var{dir}, and if
1563         found returns the full filename.
1564
1565         If @var{dir} is NULL, the search will take place starting at
1566         the current directory.
1567
1568         Returns <<NULL>> on any errors or failure to locate the .debug
1569         file, otherwise a pointer to a heap-allocated string
1570         containing the filename.  The caller is responsible for
1571         freeing this string.
1572 */
1573
1574 char *
1575 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1576 {
1577   uint32_t crc32;
1578
1579   return find_separate_debug_file (abfd, dir, true,
1580                                    bfd_get_debug_link_info_1,
1581                                    separate_debug_file_exists, &crc32);
1582 }
1583
1584 /* Helper for bfd_follow_gnu_debugaltlink.  It just returns the name
1585    of the separate debug file.  */
1586
1587 static char *
1588 get_alt_debug_link_info_shim (bfd * abfd, void *unused ATTRIBUTE_UNUSED)
1589 {
1590   bfd_size_type len;
1591   bfd_byte *buildid = NULL;
1592   char *result = bfd_get_alt_debug_link_info (abfd, &len, &buildid);
1593
1594   free (buildid);
1595
1596   return result;
1597 }
1598
1599 /*
1600 FUNCTION
1601         bfd_follow_gnu_debugaltlink
1602
1603 SYNOPSIS
1604         char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1605
1606 DESCRIPTION
1607         Takes a BFD and searches it for a .gnu_debugaltlink section.  If this
1608         section is found, it examines the section for the name of a file
1609         containing auxiliary debugging information.  It then searches the
1610         filesystem for this file in a set of standard locations, including
1611         the directory tree rooted at @var{dir}, and if found returns the
1612         full filename.
1613
1614         If @var{dir} is NULL, the search will take place starting at
1615         the current directory.
1616
1617         Returns <<NULL>> on any errors or failure to locate the debug
1618         file, otherwise a pointer to a heap-allocated string
1619         containing the filename.  The caller is responsible for
1620         freeing this string.
1621 */
1622
1623 char *
1624 bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir)
1625 {
1626   return find_separate_debug_file (abfd, dir, true,
1627                                    get_alt_debug_link_info_shim,
1628                                    separate_alt_debug_file_exists,
1629                                    NULL);
1630 }
1631
1632 /*
1633 FUNCTION
1634         bfd_create_gnu_debuglink_section
1635
1636 SYNOPSIS
1637         struct bfd_section *bfd_create_gnu_debuglink_section
1638           (bfd *abfd, const char *filename);
1639
1640 DESCRIPTION
1641         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The
1642         section is sized to be big enough to contain a link to the specified
1643         @var{filename}.
1644
1645         A pointer to the new section is returned if all is ok.  Otherwise
1646         <<NULL>> is returned and bfd_error is set.
1647 */
1648
1649 asection *
1650 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1651 {
1652   asection *sect;
1653   bfd_size_type debuglink_size;
1654   flagword flags;
1655
1656   if (abfd == NULL || filename == NULL)
1657     {
1658       bfd_set_error (bfd_error_invalid_operation);
1659       return NULL;
1660     }
1661
1662   /* Strip off any path components in filename.  */
1663   filename = lbasename (filename);
1664
1665   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1666   if (sect)
1667     {
1668       /* Section already exists.  */
1669       bfd_set_error (bfd_error_invalid_operation);
1670       return NULL;
1671     }
1672
1673   flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1674   sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1675   if (sect == NULL)
1676     return NULL;
1677
1678   /* Compute the size of the section.  Allow for the CRC after the filename,
1679      and padding so that it will start on a 4-byte boundary.  */
1680   debuglink_size = strlen (filename) + 1;
1681   debuglink_size += 3;
1682   debuglink_size &= ~3;
1683   debuglink_size += 4;
1684
1685   if (!bfd_set_section_size (sect, debuglink_size))
1686     /* XXX Should we delete the section from the bfd ?  */
1687     return NULL;
1688
1689   /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1690      Note - despite the name of the function being called, we are
1691      setting an alignment power, not a byte alignment value.  */
1692   bfd_set_section_alignment (sect, 2);
1693
1694   return sect;
1695 }
1696
1697
1698 /*
1699 FUNCTION
1700         bfd_fill_in_gnu_debuglink_section
1701
1702 SYNOPSIS
1703         bool bfd_fill_in_gnu_debuglink_section
1704           (bfd *abfd, struct bfd_section *sect, const char *filename);
1705
1706 DESCRIPTION
1707         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1708         and fills in the contents of the section to contain a link to the
1709         specified @var{filename}.  The filename should be absolute or
1710         relative to the current directory.
1711
1712         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1713         and bfd_error is set.
1714 */
1715
1716 bool
1717 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1718                                    struct bfd_section *sect,
1719                                    const char *filename)
1720 {
1721   bfd_size_type debuglink_size;
1722   uint32_t crc32;
1723   char * contents;
1724   bfd_size_type crc_offset;
1725   FILE * handle;
1726   unsigned char buffer[8 * 1024];
1727   size_t count;
1728   size_t filelen;
1729
1730   if (abfd == NULL || sect == NULL || filename == NULL)
1731     {
1732       bfd_set_error (bfd_error_invalid_operation);
1733       return false;
1734     }
1735
1736   /* Open the linked file so that we can compute a CRC.  */
1737   handle = _bfd_real_fopen (filename, FOPEN_RB);
1738   if (handle == NULL)
1739     {
1740       bfd_set_error (bfd_error_system_call);
1741       return false;
1742     }
1743
1744   crc32 = 0;
1745   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1746     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1747   fclose (handle);
1748
1749   /* Strip off any path components in filename,
1750      now that we no longer need them.  */
1751   filename = lbasename (filename);
1752
1753   filelen = strlen (filename);
1754   debuglink_size = filelen + 1;
1755   debuglink_size += 3;
1756   debuglink_size &= ~3;
1757   debuglink_size += 4;
1758
1759   contents = (char *) bfd_malloc (debuglink_size);
1760   if (contents == NULL)
1761     {
1762       /* XXX Should we delete the section from the bfd ?  */
1763       return false;
1764     }
1765
1766   crc_offset = debuglink_size - 4;
1767   memcpy (contents, filename, filelen);
1768   memset (contents + filelen, 0, crc_offset - filelen);
1769
1770   bfd_put_32 (abfd, crc32, contents + crc_offset);
1771
1772   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1773     {
1774       /* XXX Should we delete the section from the bfd ?  */
1775       free (contents);
1776       return false;
1777     }
1778
1779   return true;
1780 }
1781
1782 /* Finds the build-id associated with @var{abfd}.  If the build-id is
1783    extracted from the note section then a build-id structure is built
1784    for it, using memory allocated to @var{abfd}, and this is then
1785    attached to the @var{abfd}.
1786
1787    Returns a pointer to the build-id structure if a build-id could be
1788    found.  If no build-id is found NULL is returned and error code is
1789    set.  */
1790
1791 static struct bfd_build_id *
1792 get_build_id (bfd *abfd)
1793 {
1794   struct bfd_build_id *build_id;
1795   Elf_Internal_Note inote;
1796   Elf_External_Note *enote;
1797   bfd_byte *contents;
1798   asection *sect;
1799   bfd_size_type size;
1800
1801   BFD_ASSERT (abfd);
1802
1803   if (abfd->build_id && abfd->build_id->size > 0)
1804     /* Save some time by using the already computed build-id.  */
1805     return (struct bfd_build_id *) abfd->build_id;
1806
1807   sect = bfd_get_section_by_name (abfd, ".note.gnu.build-id");
1808   if (sect == NULL
1809       || (sect->flags & SEC_HAS_CONTENTS) == 0)
1810     {
1811       bfd_set_error (bfd_error_no_debug_section);
1812       return NULL;
1813     }
1814
1815   size = bfd_section_size (sect);
1816   /* FIXME: Should we support smaller build-id notes ?  */
1817   if (size < 0x24)
1818     {
1819       bfd_set_error (bfd_error_invalid_operation);
1820       return NULL;
1821     }
1822
1823   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1824     return NULL;
1825
1826   /* FIXME: Paranoia - allow for compressed build-id sections.
1827      Maybe we should complain if this size is different from
1828      the one obtained above...  */
1829   size = bfd_section_size (sect);
1830   if (size < sizeof (Elf_External_Note))
1831     {
1832       bfd_set_error (bfd_error_invalid_operation);
1833       free (contents);
1834       return NULL;
1835     }
1836
1837   enote = (Elf_External_Note *) contents;
1838   inote.type = H_GET_32 (abfd, enote->type);
1839   inote.namesz = H_GET_32 (abfd, enote->namesz);
1840   inote.namedata = enote->name;
1841   inote.descsz = H_GET_32 (abfd, enote->descsz);
1842   inote.descdata = inote.namedata + BFD_ALIGN (inote.namesz, 4);
1843   /* FIXME: Should we check for extra notes in this section ?  */
1844
1845   if (inote.descsz <= 0
1846       || inote.type != NT_GNU_BUILD_ID
1847       || inote.namesz != 4 /* sizeof "GNU"  */
1848       || !startswith (inote.namedata, "GNU")
1849       || inote.descsz > 0x7ffffffe
1850       || size < (12 + BFD_ALIGN (inote.namesz, 4) + inote.descsz))
1851     {
1852       free (contents);
1853       bfd_set_error (bfd_error_invalid_operation);
1854       return NULL;
1855     }
1856
1857   build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) + inote.descsz);
1858   if (build_id == NULL)
1859     {
1860       free (contents);
1861       return NULL;
1862     }
1863
1864   build_id->size = inote.descsz;
1865   memcpy (build_id->data, inote.descdata, inote.descsz);
1866   abfd->build_id = build_id;
1867   free (contents);
1868
1869   return build_id;
1870 }
1871
1872 /* Searches @var{abfd} for a build-id, and then constructs a pathname
1873    from it.  The path is computed as .build-id/NN/NN+NN.debug where
1874    NNNN+NN is the build-id value as a hexadecimal string.
1875
1876    Returns the constructed filename or NULL upon error.  It is the
1877    caller's responsibility to free the memory used to hold the
1878    filename.  If a filename is returned then the @var{build_id_out_p}
1879    parameter (which points to a @code{struct bfd_build_id} pointer) is
1880    set to a pointer to the build_id structure.  */
1881
1882 static char *
1883 get_build_id_name (bfd *abfd, void *build_id_out_p)
1884 {
1885   struct bfd_build_id **build_id_out = build_id_out_p;
1886   struct bfd_build_id *build_id;
1887   char *name;
1888   char *n;
1889   bfd_size_type s;
1890   bfd_byte *d;
1891
1892   if (abfd == NULL || bfd_get_filename (abfd) == NULL || build_id_out == NULL)
1893     {
1894       bfd_set_error (bfd_error_invalid_operation);
1895       return NULL;
1896     }
1897
1898   build_id = get_build_id (abfd);
1899   if (build_id == NULL)
1900     return NULL;
1901
1902   /* Compute the debug pathname corresponding to the build-id.  */
1903   name = bfd_malloc (strlen (".build-id/") + build_id->size * 2 + 2 + strlen (".debug"));
1904   if (name == NULL)
1905     {
1906       bfd_set_error (bfd_error_no_memory);
1907       return NULL;
1908     }
1909   n = name;
1910   d = build_id->data;
1911   s = build_id->size;
1912
1913   n += sprintf (n, ".build-id/");
1914   n += sprintf (n, "%02x", (unsigned) *d++); s--;
1915   n += sprintf (n, "/");
1916   while (s--)
1917     n += sprintf (n, "%02x", (unsigned) *d++);
1918   n += sprintf (n, ".debug");
1919
1920   *build_id_out = build_id;
1921   return name;
1922 }
1923
1924 /* Checks to see if @var{name} is a readable file and if its build-id
1925    matches @var{buildid}.
1926
1927    Returns TRUE if the file exists, is readable, and contains a
1928    build-id which matches the build-id pointed at by @var{build_id_p}
1929    (which is really a @code{struct bfd_build_id **}).  */
1930
1931 static bool
1932 check_build_id_file (const char *name, void *buildid_p)
1933 {
1934   struct bfd_build_id *orig_build_id;
1935   struct bfd_build_id *build_id;
1936   bfd * file;
1937   bool result;
1938
1939   BFD_ASSERT (name);
1940   BFD_ASSERT (buildid_p);
1941
1942   file = bfd_openr (name, NULL);
1943   if (file == NULL)
1944     return false;
1945
1946   /* If the file is an archive, process all of its elements.  */
1947   if (! bfd_check_format (file, bfd_object))
1948     {
1949       bfd_close (file);
1950       return false;
1951     }
1952
1953   build_id = get_build_id (file);
1954   if (build_id == NULL)
1955     {
1956       bfd_close (file);
1957       return false;
1958     }
1959
1960   orig_build_id = *(struct bfd_build_id **) buildid_p;
1961
1962   result = build_id->size == orig_build_id->size
1963     && memcmp (build_id->data, orig_build_id->data, build_id->size) == 0;
1964
1965   (void) bfd_close (file);
1966
1967   return result;
1968 }
1969
1970 /*
1971 FUNCTION
1972         bfd_follow_build_id_debuglink
1973
1974 SYNOPSIS
1975         char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
1976
1977 DESCRIPTION
1978         Takes @var{abfd} and searches it for a .note.gnu.build-id section.
1979         If this section is found, it extracts the value of the NT_GNU_BUILD_ID
1980         note, which should be a hexadecimal value @var{NNNN+NN} (for
1981         32+ hex digits).  It then searches the filesystem for a file named
1982         @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
1983         including the directory tree rooted at @var{dir}.  The filename
1984         of the first matching file to be found is returned.  A matching
1985         file should contain a .note.gnu.build-id section with the same
1986         @var{NNNN+NN} note as @var{abfd}, although this check is currently
1987         not implemented.
1988
1989         If @var{dir} is NULL, the search will take place starting at
1990         the current directory.
1991
1992         Returns <<NULL>> on any errors or failure to locate the debug
1993         file, otherwise a pointer to a heap-allocated string
1994         containing the filename.  The caller is responsible for
1995         freeing this string.
1996 */
1997
1998 char *
1999 bfd_follow_build_id_debuglink (bfd *abfd, const char *dir)
2000 {
2001   struct bfd_build_id *build_id;
2002
2003   return find_separate_debug_file (abfd, dir, false,
2004                                    get_build_id_name,
2005                                    check_build_id_file, &build_id);
2006 }
2007
2008 /*
2009 FUNCTION
2010         bfd_set_filename
2011
2012 SYNOPSIS
2013         const char *bfd_set_filename (bfd *abfd, const char *filename);
2014
2015 DESCRIPTION
2016         Set the filename of @var{abfd}, copying the FILENAME parameter to
2017         bfd_alloc'd memory owned by @var{abfd}.  Returns a pointer the
2018         newly allocated name, or NULL if the allocation failed.
2019 */
2020
2021 const char *
2022 bfd_set_filename (bfd *abfd, const char *filename)
2023 {
2024   size_t len = strlen (filename) + 1;
2025   char *n = bfd_alloc (abfd, len);
2026
2027   if (n == NULL)
2028     return NULL;
2029
2030   if (abfd->filename != NULL)
2031     {
2032       /* PR 29389.  If we attempt to rename a file that has been closed due
2033          to caching, then we will not be able to reopen it later on.  */
2034       if (abfd->iostream == NULL && (abfd->flags & BFD_CLOSED_BY_CACHE))
2035         {
2036           bfd_set_error (bfd_error_invalid_operation);
2037           return NULL;
2038         }
2039
2040       /* Similarly if we attempt to close a renamed file because the
2041          cache is now full, we will not be able to reopen it later on.  */
2042       if (abfd->iostream != NULL)
2043         abfd->cacheable = 0;
2044     }
2045
2046   memcpy (n, filename, len);
2047   abfd->filename = n;
2048
2049   return n;
2050 }