bfd/opncls.c

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