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