bfd/opncls.c

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