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 /* Counters used to initialize the bfd identifier.  */
  41
  42 static unsigned int bfd_id_counter = 0;
  43 static unsigned int bfd_reserved_id_counter = 0;
  44
  45 /*
  46 CODE_FRAGMENT
  47 .{* Set to N to open the next N BFDs using an alternate id space.  *}
  48 .extern unsigned int bfd_use_reserved_id;
  49 */
  50 unsigned int bfd_use_reserved_id = 0;
  51
  52 /* fdopen is a loser -- we should use stdio exclusively.  Unfortunately
  53    if we do that we can't use fcntl.  */
  54
  55 /* Return a new BFD.  All BFD's are allocated through this routine.  */
  56
  57 bfd *
  58 _bfd_new_bfd (void)
  59 {
  60   bfd *nbfd;
  61
  62   nbfd = (bfd *) bfd_zmalloc (sizeof (bfd));
  63   if (nbfd == NULL)
  64     return NULL;
  65
  66   if (bfd_use_reserved_id)
  67     {
  68       nbfd->id = --bfd_reserved_id_counter;
  69       --bfd_use_reserved_id;
  70     }
  71   else
  72     nbfd->id = bfd_id_counter++;
  73
  74   nbfd->memory = objalloc_create ();
  75   if (nbfd->memory == NULL)
  76     {
  77       bfd_set_error (bfd_error_no_memory);
  78       free (nbfd);
  79       return NULL;
  80     }
  81
  82   nbfd->arch_info = &bfd_default_arch_struct;
  83
  84   if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
  85                               sizeof (struct section_hash_entry), 13))
  86     {
  87       objalloc_free ((struct objalloc *) nbfd->memory);
  88       free (nbfd);
  89       return NULL;
  90     }
  91
  92   nbfd->archive_plugin_fd = -1;
  93
  94   return nbfd;
  95 }
  96
  97 static const struct bfd_iovec opncls_iovec;
  98
  99 /* Allocate a new BFD as a member of archive OBFD.  */
 100
 101 bfd *
 102 _bfd_new_bfd_contained_in (bfd *obfd)
 103 {
 104   bfd *nbfd;
 105
 106   /* Nested archives in bims are unsupported.  */
 107   if ((obfd->flags & BFD_IN_MEMORY) != 0)
 108     {
 109       bfd_set_error (bfd_error_malformed_archive);
 110       return NULL;
 111     }
 112   nbfd = _bfd_new_bfd ();
 113   if (nbfd == NULL)
 114     return NULL;
 115   nbfd->xvec = obfd->xvec;
 116   nbfd->iovec = obfd->iovec;
 117   if (obfd->iovec == &opncls_iovec)
 118     nbfd->iostream = obfd->iostream;
 119   nbfd->my_archive = obfd;
 120   nbfd->direction = read_direction;
 121   nbfd->target_defaulted = obfd->target_defaulted;
 122   nbfd->lto_output = obfd->lto_output;
 123   nbfd->no_export = obfd->no_export;
 124   return nbfd;
 125 }
 126
 127 /* Delete a BFD.  */
 128
 129 static void
 130 _bfd_delete_bfd (bfd *abfd)
 131 {
 132   if (abfd->memory)
 133     {
 134       bfd_hash_table_free (&abfd->section_htab);
 135       objalloc_free ((struct objalloc *) abfd->memory);
 136     }
 137   else
 138     free ((char *) bfd_get_filename (abfd));
 139
 140   free (abfd->arelt_data);
 141   free (abfd);
 142 }
 143
 144 /* Free objalloc memory.  */
 145
 146 bool
 147 _bfd_free_cached_info (bfd *abfd)
 148 {
 149   if (abfd->memory)
 150     {
 151       const char *filename = bfd_get_filename (abfd);
 152       if (filename)
 153         {
 154           /* We can't afford to lose the bfd filename when freeing
 155              abfd->memory, because that would kill the cache.c scheme
 156              of closing and reopening files in order to limit the
 157              number of open files.  To reopen, you need the filename.
 158              And indeed _bfd_compute_and_write_armap calls
 159              _bfd_free_cached_info to free up space used by symbols
 160              and by check_format_matches.  Which we want to continue
 161              doing to handle very large archives.  Later the archive
 162              elements are copied, which might require reopening files.
 163              We also want to keep using objalloc memory for the
 164              filename since that allows the name to be updated
 165              without either leaking memory or implementing some sort
 166              of reference counted string for copies of the filename.  */
 167           size_t len = strlen (filename) + 1;
 168           char *copy = bfd_malloc (len);
 169           if (copy == NULL)
 170             return false;
 171           memcpy (copy, filename, len);
 172           abfd->filename = copy;
 173         }
 174       bfd_hash_table_free (&abfd->section_htab);
 175       objalloc_free ((struct objalloc *) abfd->memory);
 176
 177       abfd->sections = NULL;
 178       abfd->section_last = NULL;
 179       abfd->outsymbols = NULL;
 180       abfd->tdata.any = NULL;
 181       abfd->usrdata = NULL;
 182       abfd->memory = NULL;
 183     }
 184
 185   return true;
 186 }
 187
 188 /*
 189 SECTION
 190         Opening and closing BFDs
 191
 192 SUBSECTION
 193         Functions for opening and closing
 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 /*
1175 INTERNAL_FUNCTION
1176         bfd_get_debug_link_info_1
1177
1178 SYNOPSIS
1179         char *bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out);
1180
1181 DESCRIPTION
1182         Extracts the filename and CRC32 value for any separate debug
1183         information file associated with @var{abfd}.
1184
1185         The @var{crc32_out} parameter is an untyped pointer because
1186         this routine is used as a @code{get_func_type} function, but it
1187         is expected to be an unsigned long pointer.
1188
1189         Returns the filename of the associated debug information file,
1190         or NULL if there is no such file.  If the filename was found
1191         then the contents of @var{crc32_out} are updated to hold the
1192         corresponding CRC32 value for the file.
1193
1194         The returned filename is allocated with @code{malloc}; freeing
1195         it is the responsibility of the caller.
1196 */
1197
1198 static char *
1199 bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out)
1200 {
1201   asection *sect;
1202   unsigned long *crc32 = (unsigned long *) crc32_out;
1203   bfd_byte *contents;
1204   unsigned int crc_offset;
1205   char *name;
1206   bfd_size_type size;
1207   ufile_ptr file_size;
1208
1209   BFD_ASSERT (abfd);
1210   BFD_ASSERT (crc32_out);
1211
1212   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1213
1214   if (sect == NULL)
1215     return NULL;
1216
1217   size = bfd_section_size (sect);
1218   file_size = bfd_get_size (abfd);
1219
1220   /* PR 22794: Make sure that the section has a reasonable size.  */
1221   if (size < 8 || (file_size != 0 && size >= file_size))
1222     return NULL;
1223
1224   if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1225     {
1226       free (contents);
1227       return NULL;
1228     }
1229
1230   /* CRC value is stored after the filename, aligned up to 4 bytes.  */
1231   name = (char *) contents;
1232   /* PR 17597: Avoid reading off the end of the buffer.  */
1233   crc_offset = strnlen (name, size) + 1;
1234   crc_offset = (crc_offset + 3) & ~3;
1235   if (crc_offset + 4 > size)
1236     return NULL;
1237
1238   *crc32 = bfd_get_32 (abfd, contents + crc_offset);
1239   return name;
1240 }
1241
1242
1243 /*
1244 FUNCTION
1245         bfd_get_debug_link_info
1246
1247 SYNOPSIS
1248         char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1249
1250 DESCRIPTION
1251         Extracts the filename and CRC32 value for any separate debug
1252         information file associated with @var{abfd}.
1253
1254         Returns the filename of the associated debug information file,
1255         or NULL if there is no such file.  If the filename was found
1256         then the contents of @var{crc32_out} are updated to hold the
1257         corresponding CRC32 value for the file.
1258
1259         The returned filename is allocated with @code{malloc}; freeing
1260         it is the responsibility of the caller.
1261 */
1262
1263 char *
1264 bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1265 {
1266   return bfd_get_debug_link_info_1 (abfd, crc32_out);
1267 }
1268
1269 /*
1270 FUNCTION
1271         bfd_get_alt_debug_link_info
1272
1273 SYNOPSIS
1274         char *bfd_get_alt_debug_link_info (bfd * abfd,
1275                                            bfd_size_type *buildid_len,
1276                                            bfd_byte **buildid_out);
1277
1278 DESCRIPTION
1279         Fetch the filename and BuildID value for any alternate debuginfo
1280         associated with @var{abfd}.  Return NULL if no such info found,
1281         otherwise return filename and update @var{buildid_len} and
1282         @var{buildid_out}.  The returned filename and build_id are
1283         allocated with @code{malloc}; freeing them is the responsibility
1284         of the caller.
1285 */
1286
1287 char *
1288 bfd_get_alt_debug_link_info (bfd * abfd, bfd_size_type *buildid_len,
1289                              bfd_byte **buildid_out)
1290 {
1291   asection *sect;
1292   bfd_byte *contents;
1293   unsigned int buildid_offset;
1294   char *name;
1295   bfd_size_type size;
1296   ufile_ptr file_size;
1297
1298   BFD_ASSERT (abfd);
1299   BFD_ASSERT (buildid_len);
1300   BFD_ASSERT (buildid_out);
1301
1302   sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK);
1303
1304   if (sect == NULL)
1305     return NULL;
1306
1307   size = bfd_section_size (sect);
1308   file_size = bfd_get_size (abfd);
1309   if (size < 8 || (file_size != 0 && size >= file_size))
1310     return NULL;
1311
1312   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1313     {
1314       free (contents);
1315       return NULL;
1316     }
1317
1318   /* BuildID value is stored after the filename.  */
1319   name = (char *) contents;
1320   buildid_offset = strnlen (name, size) + 1;
1321   if (buildid_offset >= bfd_section_size (sect))
1322     return NULL;
1323
1324   *buildid_len = size - buildid_offset;
1325   *buildid_out = bfd_malloc (*buildid_len);
1326   memcpy (*buildid_out, contents + buildid_offset, *buildid_len);
1327
1328   return name;
1329 }
1330
1331 /*
1332 INTERNAL_FUNCTION
1333         separate_debug_file_exists
1334
1335 SYNOPSIS
1336         bool separate_debug_file_exists
1337           (char *name, void *crc32_p);
1338
1339 DESCRIPTION
1340         Checks to see if @var{name} is a file and if its contents
1341         match @var{crc32}, which is a pointer to an @code{unsigned
1342         long} containing a CRC32.
1343
1344         The @var{crc32_p} parameter is an untyped pointer because
1345         this routine is used as a @code{check_func_type} function.
1346 */
1347
1348 static bool
1349 separate_debug_file_exists (const char *name, void *crc32_p)
1350 {
1351   unsigned char buffer[8 * 1024];
1352   unsigned long file_crc = 0;
1353   FILE *f;
1354   bfd_size_type count;
1355   unsigned long crc;
1356
1357   BFD_ASSERT (name);
1358   BFD_ASSERT (crc32_p);
1359
1360   crc = *(unsigned long *) crc32_p;
1361
1362   f = _bfd_real_fopen (name, FOPEN_RB);
1363   if (f == NULL)
1364     return false;
1365
1366   while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1367     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1368
1369   fclose (f);
1370
1371   return crc == file_crc;
1372 }
1373
1374 /*
1375 INTERNAL_FUNCTION
1376         separate_alt_debug_file_exists
1377
1378 SYNOPSIS
1379         bool separate_alt_debug_file_exists
1380           (char *name, void *unused);
1381
1382 DESCRIPTION
1383         Checks to see if @var{name} is a file.
1384 */
1385
1386 static bool
1387 separate_alt_debug_file_exists (const char *name, void *unused ATTRIBUTE_UNUSED)
1388 {
1389   FILE *f;
1390
1391   BFD_ASSERT (name);
1392
1393   f = _bfd_real_fopen (name, FOPEN_RB);
1394   if (f == NULL)
1395     return false;
1396
1397   fclose (f);
1398
1399   return true;
1400 }
1401
1402 /*
1403 INTERNAL_FUNCTION
1404         find_separate_debug_file
1405
1406 SYNOPSIS
1407         char *find_separate_debug_file
1408           (bfd *abfd, const char *dir, bool include_dirs,
1409            get_func_type get, check_func_type check, void *data);
1410
1411 DESCRIPTION
1412         Searches for a debug information file corresponding to @var{abfd}.
1413
1414         The name of the separate debug info file is returned by the
1415         @var{get} function.  This function scans various fixed locations
1416         in the filesystem, including the file tree rooted at @var{dir}.
1417         If the @var{include_dirs} parameter is true then the directory
1418         components of @var{abfd}'s filename will be included in the
1419         searched locations.
1420
1421         @var{data} is passed unmodified to the @var{get} and @var{check}
1422         functions.  It is generally used to implement build-id-like
1423         matching in the callback functions.
1424
1425         Returns the filename of the first file to be found which
1426         receives a TRUE result from the @var{check} function.
1427         Returns NULL if no valid file could be found.
1428 */
1429
1430 typedef char * (*get_func_type) (bfd *, void *);
1431 typedef bool (*check_func_type) (const char *, void *);
1432
1433 static char *
1434 find_separate_debug_file (bfd *abfd,
1435                           const char *debug_file_directory,
1436                           bool include_dirs,
1437                           get_func_type get_func,
1438                           check_func_type check_func,
1439                           void *func_data)
1440 {
1441   char *base;
1442   char *dir;
1443   char *debugfile;
1444   char *canon_dir;
1445   size_t dirlen;
1446   size_t canon_dirlen;
1447
1448   BFD_ASSERT (abfd);
1449   if (debug_file_directory == NULL)
1450     debug_file_directory = ".";
1451
1452   /* BFD may have been opened from a stream.  */
1453   if (bfd_get_filename (abfd) == NULL)
1454     {
1455       bfd_set_error (bfd_error_invalid_operation);
1456       return NULL;
1457     }
1458
1459   base = get_func (abfd, func_data);
1460
1461   if (base == NULL)
1462     return NULL;
1463
1464   if (base[0] == '\0')
1465     {
1466       free (base);
1467       bfd_set_error (bfd_error_no_debug_section);
1468       return NULL;
1469     }
1470
1471   if (include_dirs)
1472     {
1473       const char *fname = bfd_get_filename (abfd);
1474       for (dirlen = strlen (fname); dirlen > 0; dirlen--)
1475         if (IS_DIR_SEPARATOR (fname[dirlen - 1]))
1476           break;
1477
1478       dir = (char *) bfd_malloc (dirlen + 1);
1479       if (dir == NULL)
1480         {
1481           free (base);
1482           return NULL;
1483         }
1484       memcpy (dir, fname, dirlen);
1485       dir[dirlen] = '\0';
1486     }
1487   else
1488     {
1489       dir = (char *) bfd_malloc (1);
1490       * dir = 0;
1491       dirlen = 0;
1492     }
1493
1494   /* Compute the canonical name of the bfd object with all symbolic links
1495      resolved, for use in the global debugfile directory.  */
1496   canon_dir = lrealpath (bfd_get_filename (abfd));
1497   for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1498     if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1499       break;
1500   canon_dir[canon_dirlen] = '\0';
1501
1502 #ifndef EXTRA_DEBUG_ROOT1
1503 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1504 #endif
1505 #ifndef EXTRA_DEBUG_ROOT2
1506 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1507 #endif
1508
1509   debugfile = (char *)
1510       bfd_malloc (strlen (debug_file_directory) + 1
1511                   + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1512                   + strlen (".debug/")
1513 #ifdef EXTRA_DEBUG_ROOT1
1514                   + strlen (EXTRA_DEBUG_ROOT1)
1515 #endif
1516 #ifdef EXTRA_DEBUG_ROOT2
1517                   + strlen (EXTRA_DEBUG_ROOT2)
1518 #endif
1519                   + strlen (base)
1520                   + 1);
1521   if (debugfile == NULL)
1522     goto found; /* Actually this returns NULL.  */
1523
1524   /* First try in the same directory as the original file.
1525
1526      FIXME: Strictly speaking if we are using the build-id method,
1527      (ie include_dirs == FALSE) then we should only check absolute
1528      paths, not relative ones like this one (and the next one).
1529      The check is left in however as this allows the binutils
1530      testsuite to exercise this feature without having to install
1531      a file into the root filesystem.  (See binutils/testsuite/
1532      binutils-all/objdump.exp for the test).  */
1533   sprintf (debugfile, "%s%s", dir, base);
1534   if (check_func (debugfile, func_data))
1535     goto found;
1536
1537   /* Then try in a subdirectory called .debug.  */
1538   sprintf (debugfile, "%s.debug/%s", dir, base);
1539   if (check_func (debugfile, func_data))
1540     goto found;
1541
1542 #ifdef EXTRA_DEBUG_ROOT1
1543   /* Try the first extra debug file root.  */
1544   sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT1,
1545            include_dirs ? canon_dir : "/", base);
1546   if (check_func (debugfile, func_data))
1547     goto found;
1548 #endif
1549
1550 #ifdef EXTRA_DEBUG_ROOT2
1551   /* Try the second extra debug file root.  */
1552   sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT2,
1553            include_dirs ? canon_dir : "/", base);
1554   if (check_func (debugfile, func_data))
1555     goto found;
1556 #endif
1557
1558   /* Then try in the global debugfile directory.  */
1559   strcpy (debugfile, debug_file_directory);
1560   dirlen = strlen (debug_file_directory) - 1;
1561   if (include_dirs)
1562     {
1563       if (dirlen > 0
1564           && debug_file_directory[dirlen] != '/'
1565           && canon_dir[0] != '/')
1566         strcat (debugfile, "/");
1567       strcat (debugfile, canon_dir);
1568     }
1569   else
1570     {
1571       if (dirlen > 0 && debug_file_directory[dirlen] != '/')
1572         strcat (debugfile, "/");
1573     }
1574   strcat (debugfile, base);
1575
1576   if (check_func (debugfile, func_data))
1577     goto found;
1578
1579   /* Failed to find the file.  */
1580   free (debugfile);
1581   debugfile = NULL;
1582
1583  found:
1584   free (base);
1585   free (dir);
1586   free (canon_dir);
1587   return debugfile;
1588 }
1589
1590 /*
1591 FUNCTION
1592         bfd_follow_gnu_debuglink
1593
1594 SYNOPSIS
1595         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1596
1597 DESCRIPTION
1598         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1599         section is found, it examines the section for the name and checksum
1600         of a '.debug' file containing auxiliary debugging information.  It
1601         then searches the filesystem for this .debug file in some standard
1602         locations, including the directory tree rooted at @var{dir}, and if
1603         found returns the full filename.
1604
1605         If @var{dir} is NULL, the search will take place starting at
1606         the current directory.
1607
1608         Returns <<NULL>> on any errors or failure to locate the .debug
1609         file, otherwise a pointer to a heap-allocated string
1610         containing the filename.  The caller is responsible for
1611         freeing this string.
1612 */
1613
1614 char *
1615 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1616 {
1617   unsigned long crc32;
1618
1619   return find_separate_debug_file (abfd, dir, true,
1620                                    bfd_get_debug_link_info_1,
1621                                    separate_debug_file_exists, &crc32);
1622 }
1623
1624 /* Helper for bfd_follow_gnu_debugaltlink.  It just returns the name
1625    of the separate debug file.  */
1626
1627 static char *
1628 get_alt_debug_link_info_shim (bfd * abfd, void *unused ATTRIBUTE_UNUSED)
1629 {
1630   bfd_size_type len;
1631   bfd_byte *buildid = NULL;
1632   char *result = bfd_get_alt_debug_link_info (abfd, &len, &buildid);
1633
1634   free (buildid);
1635
1636   return result;
1637 }
1638
1639 /*
1640 FUNCTION
1641         bfd_follow_gnu_debugaltlink
1642
1643 SYNOPSIS
1644         char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1645
1646 DESCRIPTION
1647         Takes a BFD and searches it for a .gnu_debugaltlink section.  If this
1648         section is found, it examines the section for the name of a file
1649         containing auxiliary debugging information.  It then searches the
1650         filesystem for this file in a set of standard locations, including
1651         the directory tree rooted at @var{dir}, and if found returns the
1652         full filename.
1653
1654         If @var{dir} is NULL, the search will take place starting at
1655         the current directory.
1656
1657         Returns <<NULL>> on any errors or failure to locate the debug
1658         file, otherwise a pointer to a heap-allocated string
1659         containing the filename.  The caller is responsible for
1660         freeing this string.
1661 */
1662
1663 char *
1664 bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir)
1665 {
1666   return find_separate_debug_file (abfd, dir, true,
1667                                    get_alt_debug_link_info_shim,
1668                                    separate_alt_debug_file_exists,
1669                                    NULL);
1670 }
1671
1672 /*
1673 FUNCTION
1674         bfd_create_gnu_debuglink_section
1675
1676 SYNOPSIS
1677         struct bfd_section *bfd_create_gnu_debuglink_section
1678           (bfd *abfd, const char *filename);
1679
1680 DESCRIPTION
1681         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The
1682         section is sized to be big enough to contain a link to the specified
1683         @var{filename}.
1684
1685         A pointer to the new section is returned if all is ok.  Otherwise
1686         <<NULL>> is returned and bfd_error is set.
1687 */
1688
1689 asection *
1690 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1691 {
1692   asection *sect;
1693   bfd_size_type debuglink_size;
1694   flagword flags;
1695
1696   if (abfd == NULL || filename == NULL)
1697     {
1698       bfd_set_error (bfd_error_invalid_operation);
1699       return NULL;
1700     }
1701
1702   /* Strip off any path components in filename.  */
1703   filename = lbasename (filename);
1704
1705   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1706   if (sect)
1707     {
1708       /* Section already exists.  */
1709       bfd_set_error (bfd_error_invalid_operation);
1710       return NULL;
1711     }
1712
1713   flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1714   sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1715   if (sect == NULL)
1716     return NULL;
1717
1718   /* Compute the size of the section.  Allow for the CRC after the filename,
1719      and padding so that it will start on a 4-byte boundary.  */
1720   debuglink_size = strlen (filename) + 1;
1721   debuglink_size += 3;
1722   debuglink_size &= ~3;
1723   debuglink_size += 4;
1724
1725   if (!bfd_set_section_size (sect, debuglink_size))
1726     /* XXX Should we delete the section from the bfd ?  */
1727     return NULL;
1728
1729   /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1730      Note - despite the name of the function being called, we are
1731      setting an alignment power, not a byte alignment value.  */
1732   bfd_set_section_alignment (sect, 2);
1733
1734   return sect;
1735 }
1736
1737
1738 /*
1739 FUNCTION
1740         bfd_fill_in_gnu_debuglink_section
1741
1742 SYNOPSIS
1743         bool bfd_fill_in_gnu_debuglink_section
1744           (bfd *abfd, struct bfd_section *sect, const char *filename);
1745
1746 DESCRIPTION
1747         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1748         and fills in the contents of the section to contain a link to the
1749         specified @var{filename}.  The filename should be relative to the
1750         current directory.
1751
1752         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1753         and bfd_error is set.
1754 */
1755
1756 bool
1757 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1758                                    struct bfd_section *sect,
1759                                    const char *filename)
1760 {
1761   bfd_size_type debuglink_size;
1762   unsigned long crc32;
1763   char * contents;
1764   bfd_size_type crc_offset;
1765   FILE * handle;
1766   unsigned char buffer[8 * 1024];
1767   size_t count;
1768   size_t filelen;
1769
1770   if (abfd == NULL || sect == NULL || filename == NULL)
1771     {
1772       bfd_set_error (bfd_error_invalid_operation);
1773       return false;
1774     }
1775
1776   /* Make sure that we can read the file.
1777      XXX - Should we attempt to locate the debug info file using the same
1778      algorithm as gdb ?  At the moment, since we are creating the
1779      .gnu_debuglink section, we insist upon the user providing us with a
1780      correct-for-section-creation-time path, but this need not conform to
1781      the gdb location algorithm.  */
1782   handle = _bfd_real_fopen (filename, FOPEN_RB);
1783   if (handle == NULL)
1784     {
1785       bfd_set_error (bfd_error_system_call);
1786       return false;
1787     }
1788
1789   crc32 = 0;
1790   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1791     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1792   fclose (handle);
1793
1794   /* Strip off any path components in filename,
1795      now that we no longer need them.  */
1796   filename = lbasename (filename);
1797
1798   filelen = strlen (filename);
1799   debuglink_size = filelen + 1;
1800   debuglink_size += 3;
1801   debuglink_size &= ~3;
1802   debuglink_size += 4;
1803
1804   contents = (char *) bfd_malloc (debuglink_size);
1805   if (contents == NULL)
1806     {
1807       /* XXX Should we delete the section from the bfd ?  */
1808       return false;
1809     }
1810
1811   crc_offset = debuglink_size - 4;
1812   memcpy (contents, filename, filelen);
1813   memset (contents + filelen, 0, crc_offset - filelen);
1814
1815   bfd_put_32 (abfd, crc32, contents + crc_offset);
1816
1817   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1818     {
1819       /* XXX Should we delete the section from the bfd ?  */
1820       free (contents);
1821       return false;
1822     }
1823
1824   return true;
1825 }
1826
1827 /*
1828 INTERNAL_FUNCTION
1829         get_build_id
1830
1831 SYNOPSIS
1832         struct bfd_build_id * get_build_id (bfd *abfd);
1833
1834 DESCRIPTION
1835         Finds the build-id associated with @var{abfd}.  If the build-id is
1836         extracted from the note section then a build-id structure is built
1837         for it, using memory allocated to @var{abfd}, and this is then
1838         attached to the @var{abfd}.
1839
1840         Returns a pointer to the build-id structure if a build-id could be
1841         found.  If no build-id is found NULL is returned and error code is
1842         set.
1843 */
1844
1845 static struct bfd_build_id *
1846 get_build_id (bfd *abfd)
1847 {
1848   struct bfd_build_id *build_id;
1849   Elf_Internal_Note inote;
1850   Elf_External_Note *enote;
1851   bfd_byte *contents;
1852   asection *sect;
1853   bfd_size_type size;
1854
1855   BFD_ASSERT (abfd);
1856
1857   if (abfd->build_id && abfd->build_id->size > 0)
1858     /* Save some time by using the already computed build-id.  */
1859     return (struct bfd_build_id *) abfd->build_id;
1860
1861   sect = bfd_get_section_by_name (abfd, ".note.gnu.build-id");
1862   if (sect == NULL)
1863     {
1864       bfd_set_error (bfd_error_no_debug_section);
1865       return NULL;
1866     }
1867
1868   size = bfd_section_size (sect);
1869   /* FIXME: Should we support smaller build-id notes ?  */
1870   if (size < 0x24)
1871     {
1872       bfd_set_error (bfd_error_invalid_operation);
1873       return NULL;
1874     }
1875
1876   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1877     {
1878       free (contents);
1879       return NULL;
1880     }
1881
1882   /* FIXME: Paranoia - allow for compressed build-id sections.
1883      Maybe we should complain if this size is different from
1884      the one obtained above...  */
1885   size = bfd_section_size (sect);
1886   if (size < sizeof (Elf_External_Note))
1887     {
1888       bfd_set_error (bfd_error_invalid_operation);
1889       free (contents);
1890       return NULL;
1891     }
1892
1893   enote = (Elf_External_Note *) contents;
1894   inote.type = H_GET_32 (abfd, enote->type);
1895   inote.namesz = H_GET_32 (abfd, enote->namesz);
1896   inote.namedata = enote->name;
1897   inote.descsz = H_GET_32 (abfd, enote->descsz);
1898   inote.descdata = inote.namedata + BFD_ALIGN (inote.namesz, 4);
1899   /* FIXME: Should we check for extra notes in this section ?  */
1900
1901   if (inote.descsz <= 0
1902       || inote.type != NT_GNU_BUILD_ID
1903       || inote.namesz != 4 /* sizeof "GNU"  */
1904       || !startswith (inote.namedata, "GNU")
1905       || inote.descsz > 0x7ffffffe
1906       || size < (12 + BFD_ALIGN (inote.namesz, 4) + inote.descsz))
1907     {
1908       free (contents);
1909       bfd_set_error (bfd_error_invalid_operation);
1910       return NULL;
1911     }
1912
1913   build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) + inote.descsz);
1914   if (build_id == NULL)
1915     {
1916       free (contents);
1917       return NULL;
1918     }
1919
1920   build_id->size = inote.descsz;
1921   memcpy (build_id->data, inote.descdata, inote.descsz);
1922   abfd->build_id = build_id;
1923   free (contents);
1924
1925   return build_id;
1926 }
1927
1928 /*
1929 INTERNAL_FUNCTION
1930         get_build_id_name
1931
1932 SYNOPSIS
1933         char * get_build_id_name (bfd *abfd, void *build_id_out_p)
1934
1935 DESCRIPTION
1936         Searches @var{abfd} for a build-id, and then constructs a pathname
1937         from it.  The path is computed as .build-id/NN/NN+NN.debug where
1938         NNNN+NN is the build-id value as a hexadecimal string.
1939
1940         Returns the constructed filename or NULL upon error.
1941         It is the caller's responsibility to free the memory used to hold the
1942         filename.
1943         If a filename is returned then the @var{build_id_out_p}
1944         parameter (which points to a @code{struct bfd_build_id}
1945         pointer) is set to a pointer to the build_id structure.
1946 */
1947
1948 static char *
1949 get_build_id_name (bfd *abfd, void *build_id_out_p)
1950 {
1951   struct bfd_build_id **build_id_out = build_id_out_p;
1952   struct bfd_build_id *build_id;
1953   char *name;
1954   char *n;
1955   bfd_size_type s;
1956   bfd_byte *d;
1957
1958   if (abfd == NULL || bfd_get_filename (abfd) == NULL || build_id_out == NULL)
1959     {
1960       bfd_set_error (bfd_error_invalid_operation);
1961       return NULL;
1962     }
1963
1964   build_id = get_build_id (abfd);
1965   if (build_id == NULL)
1966     return NULL;
1967
1968   /* Compute the debug pathname corresponding to the build-id.  */
1969   name = bfd_malloc (strlen (".build-id/") + build_id->size * 2 + 2 + strlen (".debug"));
1970   if (name == NULL)
1971     {
1972       bfd_set_error (bfd_error_no_memory);
1973       return NULL;
1974     }
1975   n = name;
1976   d = build_id->data;
1977   s = build_id->size;
1978
1979   n += sprintf (n, ".build-id/");
1980   n += sprintf (n, "%02x", (unsigned) *d++); s--;
1981   n += sprintf (n, "/");
1982   while (s--)
1983     n += sprintf (n, "%02x", (unsigned) *d++);
1984   n += sprintf (n, ".debug");
1985
1986   *build_id_out = build_id;
1987   return name;
1988 }
1989
1990 /*
1991 INTERNAL_FUNCTION
1992         check_build_id_file
1993
1994 SYNOPSIS
1995         bool check_build_id_file (char *name, void *buildid_p);
1996
1997 DESCRIPTION
1998         Checks to see if @var{name} is a readable file and if its build-id
1999         matches @var{buildid}.
2000
2001         Returns TRUE if the file exists, is readable, and contains a
2002         build-id which matches the build-id pointed at by
2003         @var{build_id_p} (which is really a @code{struct bfd_build_id **}).
2004 */
2005
2006 static bool
2007 check_build_id_file (const char *name, void *buildid_p)
2008 {
2009   struct bfd_build_id *orig_build_id;
2010   struct bfd_build_id *build_id;
2011   bfd * file;
2012   bool result;
2013
2014   BFD_ASSERT (name);
2015   BFD_ASSERT (buildid_p);
2016
2017   file = bfd_openr (name, NULL);
2018   if (file == NULL)
2019     return false;
2020
2021   /* If the file is an archive, process all of its elements.  */
2022   if (! bfd_check_format (file, bfd_object))
2023     {
2024       bfd_close (file);
2025       return false;
2026     }
2027
2028   build_id = get_build_id (file);
2029   if (build_id == NULL)
2030     {
2031       bfd_close (file);
2032       return false;
2033     }
2034
2035   orig_build_id = *(struct bfd_build_id **) buildid_p;
2036
2037   result = build_id->size == orig_build_id->size
2038     && memcmp (build_id->data, orig_build_id->data, build_id->size) == 0;
2039
2040   (void) bfd_close (file);
2041
2042   return result;
2043 }
2044
2045 /*
2046 FUNCTION
2047         bfd_follow_build_id_debuglink
2048
2049 SYNOPSIS
2050         char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
2051
2052 DESCRIPTION
2053         Takes @var{abfd} and searches it for a .note.gnu.build-id section.
2054         If this section is found, it extracts the value of the NT_GNU_BUILD_ID
2055         note, which should be a hexadecimal value @var{NNNN+NN} (for
2056         32+ hex digits).  It then searches the filesystem for a file named
2057         @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
2058         including the directory tree rooted at @var{dir}.  The filename
2059         of the first matching file to be found is returned.  A matching
2060         file should contain a .note.gnu.build-id section with the same
2061         @var{NNNN+NN} note as @var{abfd}, although this check is currently
2062         not implemented.
2063
2064         If @var{dir} is NULL, the search will take place starting at
2065         the current directory.
2066
2067         Returns <<NULL>> on any errors or failure to locate the debug
2068         file, otherwise a pointer to a heap-allocated string
2069         containing the filename.  The caller is responsible for
2070         freeing this string.
2071 */
2072
2073 char *
2074 bfd_follow_build_id_debuglink (bfd *abfd, const char *dir)
2075 {
2076   struct bfd_build_id *build_id;
2077
2078   return find_separate_debug_file (abfd, dir, false,
2079                                    get_build_id_name,
2080                                    check_build_id_file, &build_id);
2081 }
2082
2083 /*
2084 FUNCTION
2085         bfd_set_filename
2086
2087 SYNOPSIS
2088         const char *bfd_set_filename (bfd *abfd, const char *filename);
2089
2090 DESCRIPTION
2091         Set the filename of @var{abfd}, copying the FILENAME parameter to
2092         bfd_alloc'd memory owned by @var{abfd}.  Returns a pointer the
2093         newly allocated name, or NULL if the allocation failed.
2094 */
2095
2096 const char *
2097 bfd_set_filename (bfd *abfd, const char *filename)
2098 {
2099   size_t len = strlen (filename) + 1;
2100   char *n = bfd_alloc (abfd, len);
2101
2102   if (n == NULL)
2103     return NULL;
2104
2105   if (abfd->filename != NULL)
2106     {
2107       /* PR 29389.  If we attempt to rename a file that has been closed due
2108          to caching, then we will not be able to reopen it later on.  */
2109       if (abfd->iostream == NULL && (abfd->flags & BFD_CLOSED_BY_CACHE))
2110         {
2111           bfd_set_error (bfd_error_invalid_operation);
2112           return NULL;
2113         }
2114
2115       /* Similarly if we attempt to close a renamed file because the
2116          cache is now full, we will not be able to reopen it later on.  */
2117       if (abfd->iostream != NULL)
2118         abfd->cacheable = 0;
2119     }
2120
2121   memcpy (n, filename, len);
2122   abfd->filename = n;
2123
2124   return n;
2125 }