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