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     {
1215       free (contents);
1216       return NULL;
1217     }
1218
1219   /* CRC value is stored after the filename, aligned up to 4 bytes.  */
1220   name = (char *) contents;
1221   /* PR 17597: Avoid reading off the end of the buffer.  */
1222   crc_offset = strnlen (name, size) + 1;
1223   crc_offset = (crc_offset + 3) & ~3;
1224   if (crc_offset + 4 > size)
1225     return NULL;
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     {
1301       free (contents);
1302       return NULL;
1303     }
1304
1305   /* BuildID value is stored after the filename.  */
1306   name = (char *) contents;
1307   buildid_offset = strnlen (name, size) + 1;
1308   if (buildid_offset >= bfd_section_size (sect))
1309     return NULL;
1310
1311   *buildid_len = size - buildid_offset;
1312   *buildid_out = bfd_malloc (*buildid_len);
1313   memcpy (*buildid_out, contents + buildid_offset, *buildid_len);
1314
1315   return name;
1316 }
1317
1318 /* Checks to see if @var{name} is a file and if its contents match
1319    @var{crc32}, which is a pointer to an @code{unsigned long}
1320    containing a CRC32.
1321
1322    The @var{crc32_p} parameter is an untyped pointer because this
1323    routine is used as a @code{check_func_type} function.  */
1324
1325 static bool
1326 separate_debug_file_exists (const char *name, void *crc32_p)
1327 {
1328   unsigned char buffer[8 * 1024];
1329   unsigned long file_crc = 0;
1330   FILE *f;
1331   bfd_size_type count;
1332   unsigned long crc;
1333
1334   BFD_ASSERT (name);
1335   BFD_ASSERT (crc32_p);
1336
1337   crc = *(unsigned long *) crc32_p;
1338
1339   f = _bfd_real_fopen (name, FOPEN_RB);
1340   if (f == NULL)
1341     return false;
1342
1343   while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1344     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1345
1346   fclose (f);
1347
1348   return crc == file_crc;
1349 }
1350
1351 /* Checks to see if @var{name} is a file.  */
1352
1353 static bool
1354 separate_alt_debug_file_exists (const char *name, void *unused ATTRIBUTE_UNUSED)
1355 {
1356   FILE *f;
1357
1358   BFD_ASSERT (name);
1359
1360   f = _bfd_real_fopen (name, FOPEN_RB);
1361   if (f == NULL)
1362     return false;
1363
1364   fclose (f);
1365
1366   return true;
1367 }
1368
1369 /* Searches for a debug information file corresponding to @var{abfd}.
1370
1371    The name of the separate debug info file is returned by the
1372    @var{get} function.  This function scans various fixed locations
1373    in the filesystem, including the file tree rooted at @var{dir}.
1374    If the @var{include_dirs} parameter is true then the directory
1375    components of @var{abfd}'s filename will be included in the
1376    searched locations.
1377
1378    @var{data} is passed unmodified to the @var{get} and @var{check}
1379    functions.  It is generally used to implement build-id-like
1380    matching in the callback functions.
1381
1382    Returns the filename of the first file to be found which
1383    receives a TRUE result from the @var{check} function.
1384    Returns NULL if no valid file could be found.  */
1385
1386 typedef char * (*get_func_type) (bfd *, void *);
1387 typedef bool (*check_func_type) (const char *, void *);
1388
1389 static char *
1390 find_separate_debug_file (bfd *abfd,
1391                           const char *debug_file_directory,
1392                           bool include_dirs,
1393                           get_func_type get_func,
1394                           check_func_type check_func,
1395                           void *func_data)
1396 {
1397   char *base;
1398   char *dir;
1399   char *debugfile;
1400   char *canon_dir;
1401   size_t dirlen;
1402   size_t canon_dirlen;
1403
1404   BFD_ASSERT (abfd);
1405   if (debug_file_directory == NULL)
1406     debug_file_directory = ".";
1407
1408   /* BFD may have been opened from a stream.  */
1409   if (bfd_get_filename (abfd) == NULL)
1410     {
1411       bfd_set_error (bfd_error_invalid_operation);
1412       return NULL;
1413     }
1414
1415   base = get_func (abfd, func_data);
1416
1417   if (base == NULL)
1418     return NULL;
1419
1420   if (base[0] == '\0')
1421     {
1422       free (base);
1423       bfd_set_error (bfd_error_no_debug_section);
1424       return NULL;
1425     }
1426
1427   if (include_dirs)
1428     {
1429       const char *fname = bfd_get_filename (abfd);
1430       for (dirlen = strlen (fname); dirlen > 0; dirlen--)
1431         if (IS_DIR_SEPARATOR (fname[dirlen - 1]))
1432           break;
1433
1434       dir = (char *) bfd_malloc (dirlen + 1);
1435       if (dir == NULL)
1436         {
1437           free (base);
1438           return NULL;
1439         }
1440       memcpy (dir, fname, dirlen);
1441       dir[dirlen] = '\0';
1442     }
1443   else
1444     {
1445       dir = (char *) bfd_malloc (1);
1446       * dir = 0;
1447       dirlen = 0;
1448     }
1449
1450   /* Compute the canonical name of the bfd object with all symbolic links
1451      resolved, for use in the global debugfile directory.  */
1452   canon_dir = lrealpath (bfd_get_filename (abfd));
1453   for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1454     if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1455       break;
1456   canon_dir[canon_dirlen] = '\0';
1457
1458 #ifndef EXTRA_DEBUG_ROOT1
1459 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1460 #endif
1461 #ifndef EXTRA_DEBUG_ROOT2
1462 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1463 #endif
1464
1465   debugfile = (char *)
1466       bfd_malloc (strlen (debug_file_directory) + 1
1467                   + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1468                   + strlen (".debug/")
1469 #ifdef EXTRA_DEBUG_ROOT1
1470                   + strlen (EXTRA_DEBUG_ROOT1)
1471 #endif
1472 #ifdef EXTRA_DEBUG_ROOT2
1473                   + strlen (EXTRA_DEBUG_ROOT2)
1474 #endif
1475                   + strlen (base)
1476                   + 1);
1477   if (debugfile == NULL)
1478     goto found; /* Actually this returns NULL.  */
1479
1480   /* First try in the same directory as the original file.
1481
1482      FIXME: Strictly speaking if we are using the build-id method,
1483      (ie include_dirs == FALSE) then we should only check absolute
1484      paths, not relative ones like this one (and the next one).
1485      The check is left in however as this allows the binutils
1486      testsuite to exercise this feature without having to install
1487      a file into the root filesystem.  (See binutils/testsuite/
1488      binutils-all/objdump.exp for the test).  */
1489   sprintf (debugfile, "%s%s", dir, base);
1490   if (check_func (debugfile, func_data))
1491     goto found;
1492
1493   /* Then try in a subdirectory called .debug.  */
1494   sprintf (debugfile, "%s.debug/%s", dir, base);
1495   if (check_func (debugfile, func_data))
1496     goto found;
1497
1498 #ifdef EXTRA_DEBUG_ROOT1
1499   /* Try the first extra debug file root.  */
1500   sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT1,
1501            include_dirs ? canon_dir : "/", base);
1502   if (check_func (debugfile, func_data))
1503     goto found;
1504 #endif
1505
1506 #ifdef EXTRA_DEBUG_ROOT2
1507   /* Try the second extra debug file root.  */
1508   sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT2,
1509            include_dirs ? canon_dir : "/", base);
1510   if (check_func (debugfile, func_data))
1511     goto found;
1512 #endif
1513
1514   /* Then try in the global debugfile directory.  */
1515   strcpy (debugfile, debug_file_directory);
1516   dirlen = strlen (debug_file_directory) - 1;
1517   if (include_dirs)
1518     {
1519       if (dirlen > 0
1520           && debug_file_directory[dirlen] != '/'
1521           && canon_dir[0] != '/')
1522         strcat (debugfile, "/");
1523       strcat (debugfile, canon_dir);
1524     }
1525   else
1526     {
1527       if (dirlen > 0 && debug_file_directory[dirlen] != '/')
1528         strcat (debugfile, "/");
1529     }
1530   strcat (debugfile, base);
1531
1532   if (check_func (debugfile, func_data))
1533     goto found;
1534
1535   /* Failed to find the file.  */
1536   free (debugfile);
1537   debugfile = NULL;
1538
1539  found:
1540   free (base);
1541   free (dir);
1542   free (canon_dir);
1543   return debugfile;
1544 }
1545
1546 /*
1547 FUNCTION
1548         bfd_follow_gnu_debuglink
1549
1550 SYNOPSIS
1551         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1552
1553 DESCRIPTION
1554         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1555         section is found, it examines the section for the name and checksum
1556         of a '.debug' file containing auxiliary debugging information.  It
1557         then searches the filesystem for this .debug file in some standard
1558         locations, including the directory tree rooted at @var{dir}, and if
1559         found returns the full filename.
1560
1561         If @var{dir} is NULL, the search will take place starting at
1562         the current directory.
1563
1564         Returns <<NULL>> on any errors or failure to locate the .debug
1565         file, otherwise a pointer to a heap-allocated string
1566         containing the filename.  The caller is responsible for
1567         freeing this string.
1568 */
1569
1570 char *
1571 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1572 {
1573   unsigned long crc32;
1574
1575   return find_separate_debug_file (abfd, dir, true,
1576                                    bfd_get_debug_link_info_1,
1577                                    separate_debug_file_exists, &crc32);
1578 }
1579
1580 /* Helper for bfd_follow_gnu_debugaltlink.  It just returns the name
1581    of the separate debug file.  */
1582
1583 static char *
1584 get_alt_debug_link_info_shim (bfd * abfd, void *unused ATTRIBUTE_UNUSED)
1585 {
1586   bfd_size_type len;
1587   bfd_byte *buildid = NULL;
1588   char *result = bfd_get_alt_debug_link_info (abfd, &len, &buildid);
1589
1590   free (buildid);
1591
1592   return result;
1593 }
1594
1595 /*
1596 FUNCTION
1597         bfd_follow_gnu_debugaltlink
1598
1599 SYNOPSIS
1600         char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1601
1602 DESCRIPTION
1603         Takes a BFD and searches it for a .gnu_debugaltlink section.  If this
1604         section is found, it examines the section for the name of a file
1605         containing auxiliary debugging information.  It then searches the
1606         filesystem for this file in a set of standard locations, including
1607         the directory tree rooted at @var{dir}, and if found returns the
1608         full filename.
1609
1610         If @var{dir} is NULL, the search will take place starting at
1611         the current directory.
1612
1613         Returns <<NULL>> on any errors or failure to locate the debug
1614         file, otherwise a pointer to a heap-allocated string
1615         containing the filename.  The caller is responsible for
1616         freeing this string.
1617 */
1618
1619 char *
1620 bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir)
1621 {
1622   return find_separate_debug_file (abfd, dir, true,
1623                                    get_alt_debug_link_info_shim,
1624                                    separate_alt_debug_file_exists,
1625                                    NULL);
1626 }
1627
1628 /*
1629 FUNCTION
1630         bfd_create_gnu_debuglink_section
1631
1632 SYNOPSIS
1633         struct bfd_section *bfd_create_gnu_debuglink_section
1634           (bfd *abfd, const char *filename);
1635
1636 DESCRIPTION
1637         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The
1638         section is sized to be big enough to contain a link to the specified
1639         @var{filename}.
1640
1641         A pointer to the new section is returned if all is ok.  Otherwise
1642         <<NULL>> is returned and bfd_error is set.
1643 */
1644
1645 asection *
1646 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1647 {
1648   asection *sect;
1649   bfd_size_type debuglink_size;
1650   flagword flags;
1651
1652   if (abfd == NULL || filename == NULL)
1653     {
1654       bfd_set_error (bfd_error_invalid_operation);
1655       return NULL;
1656     }
1657
1658   /* Strip off any path components in filename.  */
1659   filename = lbasename (filename);
1660
1661   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1662   if (sect)
1663     {
1664       /* Section already exists.  */
1665       bfd_set_error (bfd_error_invalid_operation);
1666       return NULL;
1667     }
1668
1669   flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1670   sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1671   if (sect == NULL)
1672     return NULL;
1673
1674   /* Compute the size of the section.  Allow for the CRC after the filename,
1675      and padding so that it will start on a 4-byte boundary.  */
1676   debuglink_size = strlen (filename) + 1;
1677   debuglink_size += 3;
1678   debuglink_size &= ~3;
1679   debuglink_size += 4;
1680
1681   if (!bfd_set_section_size (sect, debuglink_size))
1682     /* XXX Should we delete the section from the bfd ?  */
1683     return NULL;
1684
1685   /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1686      Note - despite the name of the function being called, we are
1687      setting an alignment power, not a byte alignment value.  */
1688   bfd_set_section_alignment (sect, 2);
1689
1690   return sect;
1691 }
1692
1693
1694 /*
1695 FUNCTION
1696         bfd_fill_in_gnu_debuglink_section
1697
1698 SYNOPSIS
1699         bool bfd_fill_in_gnu_debuglink_section
1700           (bfd *abfd, struct bfd_section *sect, const char *filename);
1701
1702 DESCRIPTION
1703         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1704         and fills in the contents of the section to contain a link to the
1705         specified @var{filename}.  The filename should be absolute or
1706         relative to the current directory.
1707
1708         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1709         and bfd_error is set.
1710 */
1711
1712 bool
1713 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1714                                    struct bfd_section *sect,
1715                                    const char *filename)
1716 {
1717   bfd_size_type debuglink_size;
1718   unsigned long crc32;
1719   char * contents;
1720   bfd_size_type crc_offset;
1721   FILE * handle;
1722   unsigned char buffer[8 * 1024];
1723   size_t count;
1724   size_t filelen;
1725
1726   if (abfd == NULL || sect == NULL || filename == NULL)
1727     {
1728       bfd_set_error (bfd_error_invalid_operation);
1729       return false;
1730     }
1731
1732   /* Open the linked file so that we can compute a CRC.  */
1733   handle = _bfd_real_fopen (filename, FOPEN_RB);
1734   if (handle == NULL)
1735     {
1736       bfd_set_error (bfd_error_system_call);
1737       return false;
1738     }
1739
1740   crc32 = 0;
1741   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1742     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1743   fclose (handle);
1744
1745   /* Strip off any path components in filename,
1746      now that we no longer need them.  */
1747   filename = lbasename (filename);
1748
1749   filelen = strlen (filename);
1750   debuglink_size = filelen + 1;
1751   debuglink_size += 3;
1752   debuglink_size &= ~3;
1753   debuglink_size += 4;
1754
1755   contents = (char *) bfd_malloc (debuglink_size);
1756   if (contents == NULL)
1757     {
1758       /* XXX Should we delete the section from the bfd ?  */
1759       return false;
1760     }
1761
1762   crc_offset = debuglink_size - 4;
1763   memcpy (contents, filename, filelen);
1764   memset (contents + filelen, 0, crc_offset - filelen);
1765
1766   bfd_put_32 (abfd, crc32, contents + crc_offset);
1767
1768   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1769     {
1770       /* XXX Should we delete the section from the bfd ?  */
1771       free (contents);
1772       return false;
1773     }
1774
1775   return true;
1776 }
1777
1778 /* Finds the build-id associated with @var{abfd}.  If the build-id is
1779    extracted from the note section then a build-id structure is built
1780    for it, using memory allocated to @var{abfd}, and this is then
1781    attached to the @var{abfd}.
1782
1783    Returns a pointer to the build-id structure if a build-id could be
1784    found.  If no build-id is found NULL is returned and error code is
1785    set.  */
1786
1787 static struct bfd_build_id *
1788 get_build_id (bfd *abfd)
1789 {
1790   struct bfd_build_id *build_id;
1791   Elf_Internal_Note inote;
1792   Elf_External_Note *enote;
1793   bfd_byte *contents;
1794   asection *sect;
1795   bfd_size_type size;
1796
1797   BFD_ASSERT (abfd);
1798
1799   if (abfd->build_id && abfd->build_id->size > 0)
1800     /* Save some time by using the already computed build-id.  */
1801     return (struct bfd_build_id *) abfd->build_id;
1802
1803   sect = bfd_get_section_by_name (abfd, ".note.gnu.build-id");
1804   if (sect == NULL
1805       || (sect->flags & SEC_HAS_CONTENTS) == 0)
1806     {
1807       bfd_set_error (bfd_error_no_debug_section);
1808       return NULL;
1809     }
1810
1811   size = bfd_section_size (sect);
1812   /* FIXME: Should we support smaller build-id notes ?  */
1813   if (size < 0x24)
1814     {
1815       bfd_set_error (bfd_error_invalid_operation);
1816       return NULL;
1817     }
1818
1819   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1820     {
1821       free (contents);
1822       return NULL;
1823     }
1824
1825   /* FIXME: Paranoia - allow for compressed build-id sections.
1826      Maybe we should complain if this size is different from
1827      the one obtained above...  */
1828   size = bfd_section_size (sect);
1829   if (size < sizeof (Elf_External_Note))
1830     {
1831       bfd_set_error (bfd_error_invalid_operation);
1832       free (contents);
1833       return NULL;
1834     }
1835
1836   enote = (Elf_External_Note *) contents;
1837   inote.type = H_GET_32 (abfd, enote->type);
1838   inote.namesz = H_GET_32 (abfd, enote->namesz);
1839   inote.namedata = enote->name;
1840   inote.descsz = H_GET_32 (abfd, enote->descsz);
1841   inote.descdata = inote.namedata + BFD_ALIGN (inote.namesz, 4);
1842   /* FIXME: Should we check for extra notes in this section ?  */
1843
1844   if (inote.descsz <= 0
1845       || inote.type != NT_GNU_BUILD_ID
1846       || inote.namesz != 4 /* sizeof "GNU"  */
1847       || !startswith (inote.namedata, "GNU")
1848       || inote.descsz > 0x7ffffffe
1849       || size < (12 + BFD_ALIGN (inote.namesz, 4) + inote.descsz))
1850     {
1851       free (contents);
1852       bfd_set_error (bfd_error_invalid_operation);
1853       return NULL;
1854     }
1855
1856   build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) + inote.descsz);
1857   if (build_id == NULL)
1858     {
1859       free (contents);
1860       return NULL;
1861     }
1862
1863   build_id->size = inote.descsz;
1864   memcpy (build_id->data, inote.descdata, inote.descsz);
1865   abfd->build_id = build_id;
1866   free (contents);
1867
1868   return build_id;
1869 }
1870
1871 /* Searches @var{abfd} for a build-id, and then constructs a pathname
1872    from it.  The path is computed as .build-id/NN/NN+NN.debug where
1873    NNNN+NN is the build-id value as a hexadecimal string.
1874
1875    Returns the constructed filename or NULL upon error.  It is the
1876    caller's responsibility to free the memory used to hold the
1877    filename.  If a filename is returned then the @var{build_id_out_p}
1878    parameter (which points to a @code{struct bfd_build_id} pointer) is
1879    set to a pointer to the build_id structure.  */
1880
1881 static char *
1882 get_build_id_name (bfd *abfd, void *build_id_out_p)
1883 {
1884   struct bfd_build_id **build_id_out = build_id_out_p;
1885   struct bfd_build_id *build_id;
1886   char *name;
1887   char *n;
1888   bfd_size_type s;
1889   bfd_byte *d;
1890
1891   if (abfd == NULL || bfd_get_filename (abfd) == NULL || build_id_out == NULL)
1892     {
1893       bfd_set_error (bfd_error_invalid_operation);
1894       return NULL;
1895     }
1896
1897   build_id = get_build_id (abfd);
1898   if (build_id == NULL)
1899     return NULL;
1900
1901   /* Compute the debug pathname corresponding to the build-id.  */
1902   name = bfd_malloc (strlen (".build-id/") + build_id->size * 2 + 2 + strlen (".debug"));
1903   if (name == NULL)
1904     {
1905       bfd_set_error (bfd_error_no_memory);
1906       return NULL;
1907     }
1908   n = name;
1909   d = build_id->data;
1910   s = build_id->size;
1911
1912   n += sprintf (n, ".build-id/");
1913   n += sprintf (n, "%02x", (unsigned) *d++); s--;
1914   n += sprintf (n, "/");
1915   while (s--)
1916     n += sprintf (n, "%02x", (unsigned) *d++);
1917   n += sprintf (n, ".debug");
1918
1919   *build_id_out = build_id;
1920   return name;
1921 }
1922
1923 /* Checks to see if @var{name} is a readable file and if its build-id
1924    matches @var{buildid}.
1925
1926    Returns TRUE if the file exists, is readable, and contains a
1927    build-id which matches the build-id pointed at by @var{build_id_p}
1928    (which is really a @code{struct bfd_build_id **}).  */
1929
1930 static bool
1931 check_build_id_file (const char *name, void *buildid_p)
1932 {
1933   struct bfd_build_id *orig_build_id;
1934   struct bfd_build_id *build_id;
1935   bfd * file;
1936   bool result;
1937
1938   BFD_ASSERT (name);
1939   BFD_ASSERT (buildid_p);
1940
1941   file = bfd_openr (name, NULL);
1942   if (file == NULL)
1943     return false;
1944
1945   /* If the file is an archive, process all of its elements.  */
1946   if (! bfd_check_format (file, bfd_object))
1947     {
1948       bfd_close (file);
1949       return false;
1950     }
1951
1952   build_id = get_build_id (file);
1953   if (build_id == NULL)
1954     {
1955       bfd_close (file);
1956       return false;
1957     }
1958
1959   orig_build_id = *(struct bfd_build_id **) buildid_p;
1960
1961   result = build_id->size == orig_build_id->size
1962     && memcmp (build_id->data, orig_build_id->data, build_id->size) == 0;
1963
1964   (void) bfd_close (file);
1965
1966   return result;
1967 }
1968
1969 /*
1970 FUNCTION
1971         bfd_follow_build_id_debuglink
1972
1973 SYNOPSIS
1974         char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
1975
1976 DESCRIPTION
1977         Takes @var{abfd} and searches it for a .note.gnu.build-id section.
1978         If this section is found, it extracts the value of the NT_GNU_BUILD_ID
1979         note, which should be a hexadecimal value @var{NNNN+NN} (for
1980         32+ hex digits).  It then searches the filesystem for a file named
1981         @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
1982         including the directory tree rooted at @var{dir}.  The filename
1983         of the first matching file to be found is returned.  A matching
1984         file should contain a .note.gnu.build-id section with the same
1985         @var{NNNN+NN} note as @var{abfd}, although this check is currently
1986         not implemented.
1987
1988         If @var{dir} is NULL, the search will take place starting at
1989         the current directory.
1990
1991         Returns <<NULL>> on any errors or failure to locate the debug
1992         file, otherwise a pointer to a heap-allocated string
1993         containing the filename.  The caller is responsible for
1994         freeing this string.
1995 */
1996
1997 char *
1998 bfd_follow_build_id_debuglink (bfd *abfd, const char *dir)
1999 {
2000   struct bfd_build_id *build_id;
2001
2002   return find_separate_debug_file (abfd, dir, false,
2003                                    get_build_id_name,
2004                                    check_build_id_file, &build_id);
2005 }
2006
2007 /*
2008 FUNCTION
2009         bfd_set_filename
2010
2011 SYNOPSIS
2012         const char *bfd_set_filename (bfd *abfd, const char *filename);
2013
2014 DESCRIPTION
2015         Set the filename of @var{abfd}, copying the FILENAME parameter to
2016         bfd_alloc'd memory owned by @var{abfd}.  Returns a pointer the
2017         newly allocated name, or NULL if the allocation failed.
2018 */
2019
2020 const char *
2021 bfd_set_filename (bfd *abfd, const char *filename)
2022 {
2023   size_t len = strlen (filename) + 1;
2024   char *n = bfd_alloc (abfd, len);
2025
2026   if (n == NULL)
2027     return NULL;
2028
2029   if (abfd->filename != NULL)
2030     {
2031       /* PR 29389.  If we attempt to rename a file that has been closed due
2032          to caching, then we will not be able to reopen it later on.  */
2033       if (abfd->iostream == NULL && (abfd->flags & BFD_CLOSED_BY_CACHE))
2034         {
2035           bfd_set_error (bfd_error_invalid_operation);
2036           return NULL;
2037         }
2038
2039       /* Similarly if we attempt to close a renamed file because the
2040          cache is now full, we will not be able to reopen it later on.  */
2041       if (abfd->iostream != NULL)
2042         abfd->cacheable = 0;
2043     }
2044
2045   memcpy (n, filename, len);
2046   abfd->filename = n;
2047
2048   return n;
2049 }