bfd/opncls.c

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