bfd/opncls.c

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