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         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 802 */
 803
 804 bool
 805 bfd_close (bfd *abfd)
 806 {
 807   bool ret = (!bfd_write_p (abfd)
 808               || BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)));
 809
 810   return bfd_close_all_done (abfd) && ret;
 811 }
 812
 813 /*
 814 FUNCTION
 815         bfd_close_all_done
 816
 817 SYNOPSIS
 818         bool bfd_close_all_done (bfd *);
 819
 820 DESCRIPTION
 821         Close a BFD.  Differs from <<bfd_close>> since it does not
 822         complete any pending operations.  This routine would be used
 823         if the application had just used BFD for swapping and didn't
 824         want to use any of the writing code.
 825
 826         If the created file is executable, then <<chmod>> is called
 827         to mark it as such.
 828
 829         All memory attached to the BFD is released.
 830
 831         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 832 */
 833
 834 bool
 835 bfd_close_all_done (bfd *abfd)
 836 {
 837   bool ret = BFD_SEND (abfd, _close_and_cleanup, (abfd));
 838
 839   if (ret && abfd->iovec != NULL)
 840     {
 841       ret = abfd->iovec->bclose (abfd) == 0;
 842
 843       if (ret)
 844         _maybe_make_executable (abfd);
 845     }
 846
 847   _bfd_delete_bfd (abfd);
 848
 849   return ret;
 850 }
 851
 852 /*
 853 FUNCTION
 854         bfd_create
 855
 856 SYNOPSIS
 857         bfd *bfd_create (const char *filename, bfd *templ);
 858
 859 DESCRIPTION
 860         Create a new BFD in the manner of <<bfd_openw>>, but without
 861         opening a file. The new BFD takes the target from the target
 862         used by @var{templ}. The format is always set to <<bfd_object>>.
 863
 864         A copy of the @var{filename} argument is stored in the newly created
 865         BFD.  It can be accessed via the bfd_get_filename() macro.
 866 */
 867
 868 bfd *
 869 bfd_create (const char *filename, bfd *templ)
 870 {
 871   bfd *nbfd;
 872
 873   nbfd = _bfd_new_bfd ();
 874   if (nbfd == NULL)
 875     return NULL;
 876   /* PR 11983: Do not cache the original filename, but
 877      rather make a copy - the original might go away.  */
 878   if (!bfd_set_filename (nbfd, filename))
 879     {
 880       _bfd_delete_bfd (nbfd);
 881       return NULL;
 882     }
 883   if (templ)
 884     nbfd->xvec = templ->xvec;
 885   nbfd->direction = no_direction;
 886   bfd_set_format (nbfd, bfd_object);
 887
 888   return nbfd;
 889 }
 890
 891 /*
 892 FUNCTION
 893         bfd_make_writable
 894
 895 SYNOPSIS
 896         bool bfd_make_writable (bfd *abfd);
 897
 898 DESCRIPTION
 899         Takes a BFD as created by <<bfd_create>> and converts it
 900         into one like as returned by <<bfd_openw>>.  It does this
 901         by converting the BFD to BFD_IN_MEMORY.  It's assumed that
 902         you will call <<bfd_make_readable>> on this bfd later.
 903
 904         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 905 */
 906
 907 bool
 908 bfd_make_writable (bfd *abfd)
 909 {
 910   struct bfd_in_memory *bim;
 911
 912   if (abfd->direction != no_direction)
 913     {
 914       bfd_set_error (bfd_error_invalid_operation);
 915       return false;
 916     }
 917
 918   bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
 919   if (bim == NULL)
 920     return false;       /* bfd_error already set.  */
 921   abfd->iostream = bim;
 922   /* bfd_bwrite will grow these as needed.  */
 923   bim->size = 0;
 924   bim->buffer = 0;
 925
 926   abfd->flags |= BFD_IN_MEMORY;
 927   abfd->iovec = &_bfd_memory_iovec;
 928   abfd->origin = 0;
 929   abfd->direction = write_direction;
 930   abfd->where = 0;
 931
 932   return true;
 933 }
 934
 935 /*
 936 FUNCTION
 937         bfd_make_readable
 938
 939 SYNOPSIS
 940         bool bfd_make_readable (bfd *abfd);
 941
 942 DESCRIPTION
 943         Takes a BFD as created by <<bfd_create>> and
 944         <<bfd_make_writable>> and converts it into one like as
 945         returned by <<bfd_openr>>.  It does this by writing the
 946         contents out to the memory buffer, then reversing the
 947         direction.
 948
 949         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
 950
 951 bool
 952 bfd_make_readable (bfd *abfd)
 953 {
 954   if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
 955     {
 956       bfd_set_error (bfd_error_invalid_operation);
 957       return false;
 958     }
 959
 960   if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 961     return false;
 962
 963   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 964     return false;
 965
 966   abfd->arch_info = &bfd_default_arch_struct;
 967
 968   abfd->where = 0;
 969   abfd->format = bfd_unknown;
 970   abfd->my_archive = NULL;
 971   abfd->origin = 0;
 972   abfd->opened_once = false;
 973   abfd->output_has_begun = false;
 974   abfd->section_count = 0;
 975   abfd->usrdata = NULL;
 976   abfd->cacheable = false;
 977   abfd->flags |= BFD_IN_MEMORY;
 978   abfd->mtime_set = false;
 979
 980   abfd->target_defaulted = true;
 981   abfd->direction = read_direction;
 982   abfd->sections = 0;
 983   abfd->symcount = 0;
 984   abfd->outsymbols = 0;
 985   abfd->tdata.any = 0;
 986   abfd->size = 0;
 987
 988   bfd_section_list_clear (abfd);
 989   bfd_check_format (abfd, bfd_object);
 990
 991   return true;
 992 }
 993
 994 /*
 995 FUNCTION
 996         bfd_alloc
 997
 998 SYNOPSIS
 999         void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
1000
1001 DESCRIPTION
1002         Allocate a block of @var{wanted} bytes of memory attached to
1003         <<abfd>> and return a pointer to it.
1004 */
1005
1006 void *
1007 bfd_alloc (bfd *abfd, bfd_size_type size)
1008 {
1009   void *ret;
1010   unsigned long ul_size = (unsigned long) size;
1011
1012   if (size != ul_size
1013       /* Note - although objalloc_alloc takes an unsigned long as its
1014          argument, internally the size is treated as a signed long.  This can
1015          lead to problems where, for example, a request to allocate -1 bytes
1016          can result in just 1 byte being allocated, rather than
1017          ((unsigned long) -1) bytes.  Also memory checkers will often
1018          complain about attempts to allocate a negative amount of memory.
1019          So to stop these problems we fail if the size is negative.  */
1020       || ((signed long) ul_size) < 0)
1021     {
1022       bfd_set_error (bfd_error_no_memory);
1023       return NULL;
1024     }
1025
1026   ret = objalloc_alloc ((struct objalloc *) abfd->memory, ul_size);
1027   if (ret == NULL)
1028     bfd_set_error (bfd_error_no_memory);
1029   else
1030     abfd->alloc_size += size;
1031   return ret;
1032 }
1033
1034 /*
1035 FUNCTION
1036         bfd_zalloc
1037
1038 SYNOPSIS
1039         void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
1040
1041 DESCRIPTION
1042         Allocate a block of @var{wanted} bytes of zeroed memory
1043         attached to <<abfd>> and return a pointer to it.
1044 */
1045
1046 void *
1047 bfd_zalloc (bfd *abfd, bfd_size_type size)
1048 {
1049   void *res;
1050
1051   res = bfd_alloc (abfd, size);
1052   if (res)
1053     memset (res, 0, (size_t) size);
1054   return res;
1055 }
1056
1057 /* Free a block allocated for a BFD.
1058    Note:  Also frees all more recently allocated blocks!  */
1059
1060 void
1061 bfd_release (bfd *abfd, void *block)
1062 {
1063   objalloc_free_block ((struct objalloc *) abfd->memory, block);
1064 }
1065
1066
1067 /*
1068    GNU Extension: separate debug-info files
1069
1070    The idea here is that a special section called .gnu_debuglink might be
1071    embedded in a binary file, which indicates that some *other* file
1072    contains the real debugging information. This special section contains a
1073    filename and CRC32 checksum, which we read and resolve to another file,
1074    if it exists.
1075
1076    This facilitates "optional" provision of debugging information, without
1077    having to provide two complete copies of every binary object (with and
1078    without debug symbols).  */
1079
1080 #define GNU_DEBUGLINK           ".gnu_debuglink"
1081 #define GNU_DEBUGALTLINK        ".gnu_debugaltlink"
1082
1083 /*
1084 FUNCTION
1085         bfd_calc_gnu_debuglink_crc32
1086
1087 SYNOPSIS
1088         unsigned long bfd_calc_gnu_debuglink_crc32
1089           (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1090
1091 DESCRIPTION
1092         Computes a CRC value as used in the .gnu_debuglink section.
1093         Advances the previously computed @var{crc} value by computing
1094         and adding in the crc32 for @var{len} bytes of @var{buf}.
1095
1096         Return the updated CRC32 value.
1097 */
1098
1099 unsigned long
1100 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1101                               const unsigned char *buf,
1102                               bfd_size_type len)
1103 {
1104   static const unsigned long crc32_table[256] =
1105     {
1106       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1107       0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1108       0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1109       0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1110       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1111       0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1112       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1113       0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1114       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1115       0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1116       0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1117       0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1118       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1119       0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1120       0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1121       0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1122       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1123       0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1124       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1125       0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1126       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1127       0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1128       0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1129       0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1130       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1131       0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1132       0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1133       0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1134       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1135       0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1136       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1137       0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1138       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1139       0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1140       0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1141       0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1142       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1143       0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1144       0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1145       0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1146       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1147       0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1148       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1149       0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1150       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1151       0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1152       0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1153       0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1154       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1155       0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1156       0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1157       0x2d02ef8d
1158     };
1159   const unsigned char *end;
1160
1161   crc = ~crc & 0xffffffff;
1162   for (end = buf + len; buf < end; ++ buf)
1163     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1164   return ~crc & 0xffffffff;
1165 }
1166
1167
1168 /*
1169 INTERNAL_FUNCTION
1170         bfd_get_debug_link_info_1
1171
1172 SYNOPSIS
1173         char *bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out);
1174
1175 DESCRIPTION
1176         Extracts the filename and CRC32 value for any separate debug
1177         information file associated with @var{abfd}.
1178
1179         The @var{crc32_out} parameter is an untyped pointer because
1180         this routine is used as a @code{get_func_type} function, but it
1181         is expected to be an unsigned long pointer.
1182
1183         Returns the filename of the associated debug information file,
1184         or NULL if there is no such file.  If the filename was found
1185         then the contents of @var{crc32_out} are updated to hold the
1186         corresponding CRC32 value for the file.
1187
1188         The returned filename is allocated with @code{malloc}; freeing
1189         it is the responsibility of the caller.
1190 */
1191
1192 static char *
1193 bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out)
1194 {
1195   asection *sect;
1196   unsigned long *crc32 = (unsigned long *) crc32_out;
1197   bfd_byte *contents;
1198   unsigned int crc_offset;
1199   char *name;
1200   bfd_size_type size;
1201   ufile_ptr file_size;
1202
1203   BFD_ASSERT (abfd);
1204   BFD_ASSERT (crc32_out);
1205
1206   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1207
1208   if (sect == NULL)
1209     return NULL;
1210
1211   size = bfd_section_size (sect);
1212   file_size = bfd_get_size (abfd);
1213
1214   /* PR 22794: Make sure that the section has a reasonable size.  */
1215   if (size < 8 || (file_size != 0 && size >= file_size))
1216     return NULL;
1217
1218   if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1219     {
1220       free (contents);
1221       return NULL;
1222     }
1223
1224   /* CRC value is stored after the filename, aligned up to 4 bytes.  */
1225   name = (char *) contents;
1226   /* PR 17597: Avoid reading off the end of the buffer.  */
1227   crc_offset = strnlen (name, size) + 1;
1228   crc_offset = (crc_offset + 3) & ~3;
1229   if (crc_offset + 4 > size)
1230     return NULL;
1231
1232   *crc32 = bfd_get_32 (abfd, contents + crc_offset);
1233   return name;
1234 }
1235
1236
1237 /*
1238 FUNCTION
1239         bfd_get_debug_link_info
1240
1241 SYNOPSIS
1242         char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1243
1244 DESCRIPTION
1245         Extracts the filename and CRC32 value for any separate debug
1246         information file associated with @var{abfd}.
1247
1248         Returns the filename of the associated debug information file,
1249         or NULL if there is no such file.  If the filename was found
1250         then the contents of @var{crc32_out} are updated to hold the
1251         corresponding CRC32 value for the file.
1252
1253         The returned filename is allocated with @code{malloc}; freeing
1254         it is the responsibility of the caller.
1255 */
1256
1257 char *
1258 bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1259 {
1260   return bfd_get_debug_link_info_1 (abfd, crc32_out);
1261 }
1262
1263 /*
1264 FUNCTION
1265         bfd_get_alt_debug_link_info
1266
1267 SYNOPSIS
1268         char *bfd_get_alt_debug_link_info (bfd * abfd,
1269                                            bfd_size_type *buildid_len,
1270                                            bfd_byte **buildid_out);
1271
1272 DESCRIPTION
1273         Fetch the filename and BuildID value for any alternate debuginfo
1274         associated with @var{abfd}.  Return NULL if no such info found,
1275         otherwise return filename and update @var{buildid_len} and
1276         @var{buildid_out}.  The returned filename and build_id are
1277         allocated with @code{malloc}; freeing them is the responsibility
1278         of the caller.
1279 */
1280
1281 char *
1282 bfd_get_alt_debug_link_info (bfd * abfd, bfd_size_type *buildid_len,
1283                              bfd_byte **buildid_out)
1284 {
1285   asection *sect;
1286   bfd_byte *contents;
1287   unsigned int buildid_offset;
1288   char *name;
1289   bfd_size_type size;
1290   ufile_ptr file_size;
1291
1292   BFD_ASSERT (abfd);
1293   BFD_ASSERT (buildid_len);
1294   BFD_ASSERT (buildid_out);
1295
1296   sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK);
1297
1298   if (sect == NULL)
1299     return NULL;
1300
1301   size = bfd_section_size (sect);
1302   file_size = bfd_get_size (abfd);
1303   if (size < 8 || (file_size != 0 && size >= file_size))
1304     return NULL;
1305
1306   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1307     {
1308       free (contents);
1309       return NULL;
1310     }
1311
1312   /* BuildID value is stored after the filename.  */
1313   name = (char *) contents;
1314   buildid_offset = strnlen (name, size) + 1;
1315   if (buildid_offset >= bfd_section_size (sect))
1316     return NULL;
1317
1318   *buildid_len = size - buildid_offset;
1319   *buildid_out = bfd_malloc (*buildid_len);
1320   memcpy (*buildid_out, contents + buildid_offset, *buildid_len);
1321
1322   return name;
1323 }
1324
1325 /*
1326 INTERNAL_FUNCTION
1327         separate_debug_file_exists
1328
1329 SYNOPSIS
1330         bool separate_debug_file_exists
1331           (char *name, void *crc32_p);
1332
1333 DESCRIPTION
1334         Checks to see if @var{name} is a file and if its contents
1335         match @var{crc32}, which is a pointer to an @code{unsigned
1336         long} containing a CRC32.
1337
1338         The @var{crc32_p} parameter is an untyped pointer because
1339         this routine is used as a @code{check_func_type} function.
1340 */
1341
1342 static bool
1343 separate_debug_file_exists (const char *name, void *crc32_p)
1344 {
1345   unsigned char buffer[8 * 1024];
1346   unsigned long file_crc = 0;
1347   FILE *f;
1348   bfd_size_type count;
1349   unsigned long crc;
1350
1351   BFD_ASSERT (name);
1352   BFD_ASSERT (crc32_p);
1353
1354   crc = *(unsigned long *) crc32_p;
1355
1356   f = _bfd_real_fopen (name, FOPEN_RB);
1357   if (f == NULL)
1358     return false;
1359
1360   while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1361     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1362
1363   fclose (f);
1364
1365   return crc == file_crc;
1366 }
1367
1368 /*
1369 INTERNAL_FUNCTION
1370         separate_alt_debug_file_exists
1371
1372 SYNOPSIS
1373         bool separate_alt_debug_file_exists
1374           (char *name, void *unused);
1375
1376 DESCRIPTION
1377         Checks to see if @var{name} is a file.
1378 */
1379
1380 static bool
1381 separate_alt_debug_file_exists (const char *name, void *unused ATTRIBUTE_UNUSED)
1382 {
1383   FILE *f;
1384
1385   BFD_ASSERT (name);
1386
1387   f = _bfd_real_fopen (name, FOPEN_RB);
1388   if (f == NULL)
1389     return false;
1390
1391   fclose (f);
1392
1393   return true;
1394 }
1395
1396 /*
1397 INTERNAL_FUNCTION
1398         find_separate_debug_file
1399
1400 SYNOPSIS
1401         char *find_separate_debug_file
1402           (bfd *abfd, const char *dir, bool include_dirs,
1403            get_func_type get, check_func_type check, void *data);
1404
1405 DESCRIPTION
1406         Searches for a debug information file corresponding to @var{abfd}.
1407
1408         The name of the separate debug info file is returned by the
1409         @var{get} function.  This function scans various fixed locations
1410         in the filesystem, including the file tree rooted at @var{dir}.
1411         If the @var{include_dirs} parameter is true then the directory
1412         components of @var{abfd}'s filename will be included in the
1413         searched locations.
1414
1415         @var{data} is passed unmodified to the @var{get} and @var{check}
1416         functions.  It is generally used to implement build-id-like
1417         matching in the callback functions.
1418
1419         Returns the filename of the first file to be found which
1420         receives a TRUE result from the @var{check} function.
1421         Returns NULL if no valid file could be found.
1422 */
1423
1424 typedef char * (*get_func_type) (bfd *, void *);
1425 typedef bool (*check_func_type) (const char *, void *);
1426
1427 static char *
1428 find_separate_debug_file (bfd *abfd,
1429                           const char *debug_file_directory,
1430                           bool include_dirs,
1431                           get_func_type get_func,
1432                           check_func_type check_func,
1433                           void *func_data)
1434 {
1435   char *base;
1436   char *dir;
1437   char *debugfile;
1438   char *canon_dir;
1439   size_t dirlen;
1440   size_t canon_dirlen;
1441
1442   BFD_ASSERT (abfd);
1443   if (debug_file_directory == NULL)
1444     debug_file_directory = ".";
1445
1446   /* BFD may have been opened from a stream.  */
1447   if (bfd_get_filename (abfd) == NULL)
1448     {
1449       bfd_set_error (bfd_error_invalid_operation);
1450       return NULL;
1451     }
1452
1453   base = get_func (abfd, func_data);
1454
1455   if (base == NULL)
1456     return NULL;
1457
1458   if (base[0] == '\0')
1459     {
1460       free (base);
1461       bfd_set_error (bfd_error_no_debug_section);
1462       return NULL;
1463     }
1464
1465   if (include_dirs)
1466     {
1467       const char *fname = bfd_get_filename (abfd);
1468       for (dirlen = strlen (fname); dirlen > 0; dirlen--)
1469         if (IS_DIR_SEPARATOR (fname[dirlen - 1]))
1470           break;
1471
1472       dir = (char *) bfd_malloc (dirlen + 1);
1473       if (dir == NULL)
1474         {
1475           free (base);
1476           return NULL;
1477         }
1478       memcpy (dir, fname, dirlen);
1479       dir[dirlen] = '\0';
1480     }
1481   else
1482     {
1483       dir = (char *) bfd_malloc (1);
1484       * dir = 0;
1485       dirlen = 0;
1486     }
1487
1488   /* Compute the canonical name of the bfd object with all symbolic links
1489      resolved, for use in the global debugfile directory.  */
1490   canon_dir = lrealpath (bfd_get_filename (abfd));
1491   for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1492     if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1493       break;
1494   canon_dir[canon_dirlen] = '\0';
1495
1496 #ifndef EXTRA_DEBUG_ROOT1
1497 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1498 #endif
1499 #ifndef EXTRA_DEBUG_ROOT2
1500 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1501 #endif
1502
1503   debugfile = (char *)
1504       bfd_malloc (strlen (debug_file_directory) + 1
1505                   + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1506                   + strlen (".debug/")
1507 #ifdef EXTRA_DEBUG_ROOT1
1508                   + strlen (EXTRA_DEBUG_ROOT1)
1509 #endif
1510 #ifdef EXTRA_DEBUG_ROOT2
1511                   + strlen (EXTRA_DEBUG_ROOT2)
1512 #endif
1513                   + strlen (base)
1514                   + 1);
1515   if (debugfile == NULL)
1516     goto found; /* Actually this returns NULL.  */
1517
1518   /* First try in the same directory as the original file.
1519
1520      FIXME: Strictly speaking if we are using the build-id method,
1521      (ie include_dirs == FALSE) then we should only check absolute
1522      paths, not relative ones like this one (and the next one).
1523      The check is left in however as this allows the binutils
1524      testsuite to exercise this feature without having to install
1525      a file into the root filesystem.  (See binutils/testsuite/
1526      binutils-all/objdump.exp for the test).  */
1527   sprintf (debugfile, "%s%s", dir, base);
1528   if (check_func (debugfile, func_data))
1529     goto found;
1530
1531   /* Then try in a subdirectory called .debug.  */
1532   sprintf (debugfile, "%s.debug/%s", dir, base);
1533   if (check_func (debugfile, func_data))
1534     goto found;
1535
1536 #ifdef EXTRA_DEBUG_ROOT1
1537   /* Try the first extra debug file root.  */
1538   sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT1,
1539            include_dirs ? canon_dir : "/", base);
1540   if (check_func (debugfile, func_data))
1541     goto found;
1542 #endif
1543
1544 #ifdef EXTRA_DEBUG_ROOT2
1545   /* Try the second extra debug file root.  */
1546   sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT2,
1547            include_dirs ? canon_dir : "/", base);
1548   if (check_func (debugfile, func_data))
1549     goto found;
1550 #endif
1551
1552   /* Then try in the global debugfile directory.  */
1553   strcpy (debugfile, debug_file_directory);
1554   dirlen = strlen (debug_file_directory) - 1;
1555   if (include_dirs)
1556     {
1557       if (dirlen > 0
1558           && debug_file_directory[dirlen] != '/'
1559           && canon_dir[0] != '/')
1560         strcat (debugfile, "/");
1561       strcat (debugfile, canon_dir);
1562     }
1563   else
1564     {
1565       if (dirlen > 0 && debug_file_directory[dirlen] != '/')
1566         strcat (debugfile, "/");
1567     }
1568   strcat (debugfile, base);
1569
1570   if (check_func (debugfile, func_data))
1571     goto found;
1572
1573   /* Failed to find the file.  */
1574   free (debugfile);
1575   debugfile = NULL;
1576
1577  found:
1578   free (base);
1579   free (dir);
1580   free (canon_dir);
1581   return debugfile;
1582 }
1583
1584 /*
1585 FUNCTION
1586         bfd_follow_gnu_debuglink
1587
1588 SYNOPSIS
1589         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1590
1591 DESCRIPTION
1592         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1593         section is found, it examines the section for the name and checksum
1594         of a '.debug' file containing auxiliary debugging information.  It
1595         then searches the filesystem for this .debug file in some standard
1596         locations, including the directory tree rooted at @var{dir}, and if
1597         found returns the full filename.
1598
1599         If @var{dir} is NULL, the search will take place starting at
1600         the current directory.
1601
1602         Returns <<NULL>> on any errors or failure to locate the .debug
1603         file, otherwise a pointer to a heap-allocated string
1604         containing the filename.  The caller is responsible for
1605         freeing this string.
1606 */
1607
1608 char *
1609 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1610 {
1611   unsigned long crc32;
1612
1613   return find_separate_debug_file (abfd, dir, true,
1614                                    bfd_get_debug_link_info_1,
1615                                    separate_debug_file_exists, &crc32);
1616 }
1617
1618 /* Helper for bfd_follow_gnu_debugaltlink.  It just returns the name
1619    of the separate debug file.  */
1620
1621 static char *
1622 get_alt_debug_link_info_shim (bfd * abfd, void *unused ATTRIBUTE_UNUSED)
1623 {
1624   bfd_size_type len;
1625   bfd_byte *buildid = NULL;
1626   char *result = bfd_get_alt_debug_link_info (abfd, &len, &buildid);
1627
1628   free (buildid);
1629
1630   return result;
1631 }
1632
1633 /*
1634 FUNCTION
1635         bfd_follow_gnu_debugaltlink
1636
1637 SYNOPSIS
1638         char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1639
1640 DESCRIPTION
1641         Takes a BFD and searches it for a .gnu_debugaltlink section.  If this
1642         section is found, it examines the section for the name of a file
1643         containing auxiliary debugging information.  It then searches the
1644         filesystem for this file in a set of standard locations, including
1645         the directory tree rooted at @var{dir}, and if found returns the
1646         full filename.
1647
1648         If @var{dir} is NULL, the search will take place starting at
1649         the current directory.
1650
1651         Returns <<NULL>> on any errors or failure to locate the debug
1652         file, otherwise a pointer to a heap-allocated string
1653         containing the filename.  The caller is responsible for
1654         freeing this string.
1655 */
1656
1657 char *
1658 bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir)
1659 {
1660   return find_separate_debug_file (abfd, dir, true,
1661                                    get_alt_debug_link_info_shim,
1662                                    separate_alt_debug_file_exists,
1663                                    NULL);
1664 }
1665
1666 /*
1667 FUNCTION
1668         bfd_create_gnu_debuglink_section
1669
1670 SYNOPSIS
1671         struct bfd_section *bfd_create_gnu_debuglink_section
1672           (bfd *abfd, const char *filename);
1673
1674 DESCRIPTION
1675         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The
1676         section is sized to be big enough to contain a link to the specified
1677         @var{filename}.
1678
1679         A pointer to the new section is returned if all is ok.  Otherwise
1680         <<NULL>> is returned and bfd_error is set.
1681 */
1682
1683 asection *
1684 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1685 {
1686   asection *sect;
1687   bfd_size_type debuglink_size;
1688   flagword flags;
1689
1690   if (abfd == NULL || filename == NULL)
1691     {
1692       bfd_set_error (bfd_error_invalid_operation);
1693       return NULL;
1694     }
1695
1696   /* Strip off any path components in filename.  */
1697   filename = lbasename (filename);
1698
1699   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1700   if (sect)
1701     {
1702       /* Section already exists.  */
1703       bfd_set_error (bfd_error_invalid_operation);
1704       return NULL;
1705     }
1706
1707   flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1708   sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1709   if (sect == NULL)
1710     return NULL;
1711
1712   /* Compute the size of the section.  Allow for the CRC after the filename,
1713      and padding so that it will start on a 4-byte boundary.  */
1714   debuglink_size = strlen (filename) + 1;
1715   debuglink_size += 3;
1716   debuglink_size &= ~3;
1717   debuglink_size += 4;
1718
1719   if (!bfd_set_section_size (sect, debuglink_size))
1720     /* XXX Should we delete the section from the bfd ?  */
1721     return NULL;
1722
1723   /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1724      Note - despite the name of the function being called, we are
1725      setting an alignment power, not a byte alignment value.  */
1726   bfd_set_section_alignment (sect, 2);
1727
1728   return sect;
1729 }
1730
1731
1732 /*
1733 FUNCTION
1734         bfd_fill_in_gnu_debuglink_section
1735
1736 SYNOPSIS
1737         bool bfd_fill_in_gnu_debuglink_section
1738           (bfd *abfd, struct bfd_section *sect, const char *filename);
1739
1740 DESCRIPTION
1741         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1742         and fills in the contents of the section to contain a link to the
1743         specified @var{filename}.  The filename should be relative to the
1744         current directory.
1745
1746         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1747         and bfd_error is set.
1748 */
1749
1750 bool
1751 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1752                                    struct bfd_section *sect,
1753                                    const char *filename)
1754 {
1755   bfd_size_type debuglink_size;
1756   unsigned long crc32;
1757   char * contents;
1758   bfd_size_type crc_offset;
1759   FILE * handle;
1760   unsigned char buffer[8 * 1024];
1761   size_t count;
1762   size_t filelen;
1763
1764   if (abfd == NULL || sect == NULL || filename == NULL)
1765     {
1766       bfd_set_error (bfd_error_invalid_operation);
1767       return false;
1768     }
1769
1770   /* Make sure that we can read the file.
1771      XXX - Should we attempt to locate the debug info file using the same
1772      algorithm as gdb ?  At the moment, since we are creating the
1773      .gnu_debuglink section, we insist upon the user providing us with a
1774      correct-for-section-creation-time path, but this need not conform to
1775      the gdb location algorithm.  */
1776   handle = _bfd_real_fopen (filename, FOPEN_RB);
1777   if (handle == NULL)
1778     {
1779       bfd_set_error (bfd_error_system_call);
1780       return false;
1781     }
1782
1783   crc32 = 0;
1784   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1785     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1786   fclose (handle);
1787
1788   /* Strip off any path components in filename,
1789      now that we no longer need them.  */
1790   filename = lbasename (filename);
1791
1792   filelen = strlen (filename);
1793   debuglink_size = filelen + 1;
1794   debuglink_size += 3;
1795   debuglink_size &= ~3;
1796   debuglink_size += 4;
1797
1798   contents = (char *) bfd_malloc (debuglink_size);
1799   if (contents == NULL)
1800     {
1801       /* XXX Should we delete the section from the bfd ?  */
1802       return false;
1803     }
1804
1805   crc_offset = debuglink_size - 4;
1806   memcpy (contents, filename, filelen);
1807   memset (contents + filelen, 0, crc_offset - filelen);
1808
1809   bfd_put_32 (abfd, crc32, contents + crc_offset);
1810
1811   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1812     {
1813       /* XXX Should we delete the section from the bfd ?  */
1814       free (contents);
1815       return false;
1816     }
1817
1818   return true;
1819 }
1820
1821 /*
1822 INTERNAL_FUNCTION
1823         get_build_id
1824
1825 SYNOPSIS
1826         struct bfd_build_id * get_build_id (bfd *abfd);
1827
1828 DESCRIPTION
1829         Finds the build-id associated with @var{abfd}.  If the build-id is
1830         extracted from the note section then a build-id structure is built
1831         for it, using memory allocated to @var{abfd}, and this is then
1832         attached to the @var{abfd}.
1833
1834         Returns a pointer to the build-id structure if a build-id could be
1835         found.  If no build-id is found NULL is returned and error code is
1836         set.
1837 */
1838
1839 static struct bfd_build_id *
1840 get_build_id (bfd *abfd)
1841 {
1842   struct bfd_build_id *build_id;
1843   Elf_Internal_Note inote;
1844   Elf_External_Note *enote;
1845   bfd_byte *contents;
1846   asection *sect;
1847   bfd_size_type size;
1848
1849   BFD_ASSERT (abfd);
1850
1851   if (abfd->build_id && abfd->build_id->size > 0)
1852     /* Save some time by using the already computed build-id.  */
1853     return (struct bfd_build_id *) abfd->build_id;
1854
1855   sect = bfd_get_section_by_name (abfd, ".note.gnu.build-id");
1856   if (sect == NULL)
1857     {
1858       bfd_set_error (bfd_error_no_debug_section);
1859       return NULL;
1860     }
1861
1862   size = bfd_section_size (sect);
1863   /* FIXME: Should we support smaller build-id notes ?  */
1864   if (size < 0x24)
1865     {
1866       bfd_set_error (bfd_error_invalid_operation);
1867       return NULL;
1868     }
1869
1870   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1871     {
1872       free (contents);
1873       return NULL;
1874     }
1875
1876   /* FIXME: Paranoia - allow for compressed build-id sections.
1877      Maybe we should complain if this size is different from
1878      the one obtained above...  */
1879   size = bfd_section_size (sect);
1880   if (size < sizeof (Elf_External_Note))
1881     {
1882       bfd_set_error (bfd_error_invalid_operation);
1883       free (contents);
1884       return NULL;
1885     }
1886
1887   enote = (Elf_External_Note *) contents;
1888   inote.type = H_GET_32 (abfd, enote->type);
1889   inote.namesz = H_GET_32 (abfd, enote->namesz);
1890   inote.namedata = enote->name;
1891   inote.descsz = H_GET_32 (abfd, enote->descsz);
1892   inote.descdata = inote.namedata + BFD_ALIGN (inote.namesz, 4);
1893   /* FIXME: Should we check for extra notes in this section ?  */
1894
1895   if (inote.descsz <= 0
1896       || inote.type != NT_GNU_BUILD_ID
1897       || inote.namesz != 4 /* sizeof "GNU"  */
1898       || !startswith (inote.namedata, "GNU")
1899       || inote.descsz > 0x7ffffffe
1900       || size < (12 + BFD_ALIGN (inote.namesz, 4) + inote.descsz))
1901     {
1902       free (contents);
1903       bfd_set_error (bfd_error_invalid_operation);
1904       return NULL;
1905     }
1906
1907   build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) + inote.descsz);
1908   if (build_id == NULL)
1909     {
1910       free (contents);
1911       return NULL;
1912     }
1913
1914   build_id->size = inote.descsz;
1915   memcpy (build_id->data, inote.descdata, inote.descsz);
1916   abfd->build_id = build_id;
1917   free (contents);
1918
1919   return build_id;
1920 }
1921
1922 /*
1923 INTERNAL_FUNCTION
1924         get_build_id_name
1925
1926 SYNOPSIS
1927         char * get_build_id_name (bfd *abfd, void *build_id_out_p)
1928
1929 DESCRIPTION
1930         Searches @var{abfd} for a build-id, and then constructs a pathname
1931         from it.  The path is computed as .build-id/NN/NN+NN.debug where
1932         NNNN+NN is the build-id value as a hexadecimal string.
1933
1934         Returns the constructed filename or NULL upon error.
1935         It is the caller's responsibility to free the memory used to hold the
1936         filename.
1937         If a filename is returned then the @var{build_id_out_p}
1938         parameter (which points to a @code{struct bfd_build_id}
1939         pointer) is set to a pointer to the build_id structure.
1940 */
1941
1942 static char *
1943 get_build_id_name (bfd *abfd, void *build_id_out_p)
1944 {
1945   struct bfd_build_id **build_id_out = build_id_out_p;
1946   struct bfd_build_id *build_id;
1947   char *name;
1948   char *n;
1949   bfd_size_type s;
1950   bfd_byte *d;
1951
1952   if (abfd == NULL || bfd_get_filename (abfd) == NULL || build_id_out == NULL)
1953     {
1954       bfd_set_error (bfd_error_invalid_operation);
1955       return NULL;
1956     }
1957
1958   build_id = get_build_id (abfd);
1959   if (build_id == NULL)
1960     return NULL;
1961
1962   /* Compute the debug pathname corresponding to the build-id.  */
1963   name = bfd_malloc (strlen (".build-id/") + build_id->size * 2 + 2 + strlen (".debug"));
1964   if (name == NULL)
1965     {
1966       bfd_set_error (bfd_error_no_memory);
1967       return NULL;
1968     }
1969   n = name;
1970   d = build_id->data;
1971   s = build_id->size;
1972
1973   n += sprintf (n, ".build-id/");
1974   n += sprintf (n, "%02x", (unsigned) *d++); s--;
1975   n += sprintf (n, "/");
1976   while (s--)
1977     n += sprintf (n, "%02x", (unsigned) *d++);
1978   n += sprintf (n, ".debug");
1979
1980   *build_id_out = build_id;
1981   return name;
1982 }
1983
1984 /*
1985 INTERNAL_FUNCTION
1986         check_build_id_file
1987
1988 SYNOPSIS
1989         bool check_build_id_file (char *name, void *buildid_p);
1990
1991 DESCRIPTION
1992         Checks to see if @var{name} is a readable file and if its build-id
1993         matches @var{buildid}.
1994
1995         Returns TRUE if the file exists, is readable, and contains a
1996         build-id which matches the build-id pointed at by
1997         @var{build_id_p} (which is really a @code{struct bfd_build_id **}).
1998 */
1999
2000 static bool
2001 check_build_id_file (const char *name, void *buildid_p)
2002 {
2003   struct bfd_build_id *orig_build_id;
2004   struct bfd_build_id *build_id;
2005   bfd * file;
2006   bool result;
2007
2008   BFD_ASSERT (name);
2009   BFD_ASSERT (buildid_p);
2010
2011   file = bfd_openr (name, NULL);
2012   if (file == NULL)
2013     return false;
2014
2015   /* If the file is an archive, process all of its elements.  */
2016   if (! bfd_check_format (file, bfd_object))
2017     {
2018       bfd_close (file);
2019       return false;
2020     }
2021
2022   build_id = get_build_id (file);
2023   if (build_id == NULL)
2024     {
2025       bfd_close (file);
2026       return false;
2027     }
2028
2029   orig_build_id = *(struct bfd_build_id **) buildid_p;
2030
2031   result = build_id->size == orig_build_id->size
2032     && memcmp (build_id->data, orig_build_id->data, build_id->size) == 0;
2033
2034   (void) bfd_close (file);
2035
2036   return result;
2037 }
2038
2039 /*
2040 FUNCTION
2041         bfd_follow_build_id_debuglink
2042
2043 SYNOPSIS
2044         char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
2045
2046 DESCRIPTION
2047         Takes @var{abfd} and searches it for a .note.gnu.build-id section.
2048         If this section is found, it extracts the value of the NT_GNU_BUILD_ID
2049         note, which should be a hexadecimal value @var{NNNN+NN} (for
2050         32+ hex digits).  It then searches the filesystem for a file named
2051         @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
2052         including the directory tree rooted at @var{dir}.  The filename
2053         of the first matching file to be found is returned.  A matching
2054         file should contain a .note.gnu.build-id section with the same
2055         @var{NNNN+NN} note as @var{abfd}, although this check is currently
2056         not implemented.
2057
2058         If @var{dir} is NULL, the search will take place starting at
2059         the current directory.
2060
2061         Returns <<NULL>> on any errors or failure to locate the debug
2062         file, otherwise a pointer to a heap-allocated string
2063         containing the filename.  The caller is responsible for
2064         freeing this string.
2065 */
2066
2067 char *
2068 bfd_follow_build_id_debuglink (bfd *abfd, const char *dir)
2069 {
2070   struct bfd_build_id *build_id;
2071
2072   return find_separate_debug_file (abfd, dir, false,
2073                                    get_build_id_name,
2074                                    check_build_id_file, &build_id);
2075 }
2076
2077 /*
2078 FUNCTION
2079         bfd_set_filename
2080
2081 SYNOPSIS
2082         const char *bfd_set_filename (bfd *abfd, const char *filename);
2083
2084 DESCRIPTION
2085         Set the filename of @var{abfd}, copying the FILENAME parameter to
2086         bfd_alloc'd memory owned by @var{abfd}.  Returns a pointer the
2087         newly allocated name, or NULL if the allocation failed.
2088 */
2089
2090 const char *
2091 bfd_set_filename (bfd *abfd, const char *filename)
2092 {
2093   size_t len = strlen (filename) + 1;
2094   char *n = bfd_alloc (abfd, len);
2095
2096   if (n == NULL)
2097     return NULL;
2098
2099   if (abfd->filename != NULL)
2100     {
2101       /* PR 29389.  If we attempt to rename a file that has been closed due
2102          to caching, then we will not be able to reopen it later on.  */
2103       if (abfd->iostream == NULL && (abfd->flags & BFD_CLOSED_BY_CACHE))
2104         {
2105           bfd_set_error (bfd_error_invalid_operation);
2106           return NULL;
2107         }
2108
2109       /* Similarly if we attempt to close a renamed file because the
2110          cache is now full, we will not be able to reopen it later on.  */
2111       if (abfd->iostream != NULL)
2112         abfd->cacheable = 0;
2113     }
2114
2115   memcpy (n, filename, len);
2116   abfd->filename = n;
2117
2118   return n;
2119 }