bfd/opncls.c

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