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