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   if (abfd->filename)
 130     free ((char *) abfd->filename);
 131   free (abfd->arelt_data);
 132   free (abfd);
 133 }
 134
 135 /* Free objalloc memory.  */
 136
 137 bfd_boolean
 138 _bfd_free_cached_info (bfd *abfd)
 139 {
 140   if (abfd->memory)
 141     {
 142       bfd_hash_table_free (&abfd->section_htab);
 143       objalloc_free ((struct objalloc *) abfd->memory);
 144
 145       abfd->sections = NULL;
 146       abfd->section_last = NULL;
 147       abfd->outsymbols = NULL;
 148       abfd->tdata.any = NULL;
 149       abfd->usrdata = NULL;
 150       abfd->memory = NULL;
 151     }
 152
 153   return TRUE;
 154 }
 155
 156 /*
 157 SECTION
 158         Opening and closing BFDs
 159
 160 SUBSECTION
 161         Functions for opening and closing
 162 */
 163
 164 /*
 165 FUNCTION
 166         bfd_fopen
 167
 168 SYNOPSIS
 169         bfd *bfd_fopen (const char *filename, const char *target,
 170                         const char *mode, int fd);
 171
 172 DESCRIPTION
 173         Open the file @var{filename} with the target @var{target}.
 174         Return a pointer to the created BFD.  If @var{fd} is not -1,
 175         then <<fdopen>> is used to open the file; otherwise, <<fopen>>
 176         is used.  @var{mode} is passed directly to <<fopen>> or
 177         <<fdopen>>.
 178
 179         Calls <<bfd_find_target>>, so @var{target} is interpreted as by
 180         that function.
 181
 182         The new BFD is marked as cacheable iff @var{fd} is -1.
 183
 184         If <<NULL>> is returned then an error has occured.   Possible errors
 185         are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
 186         <<system_call>> error.
 187
 188         On error, @var{fd} is always closed.
 189
 190         A copy of the @var{filename} argument is stored in the newly created
 191         BFD.  It can be accessed via the bfd_get_filename() macro.
 192 */
 193
 194 bfd *
 195 bfd_fopen (const char *filename, const char *target, const char *mode, int fd)
 196 {
 197   bfd *nbfd;
 198   const bfd_target *target_vec;
 199
 200   nbfd = _bfd_new_bfd ();
 201   if (nbfd == NULL)
 202     {
 203       if (fd != -1)
 204         close (fd);
 205       return NULL;
 206     }
 207
 208   target_vec = bfd_find_target (target, nbfd);
 209   if (target_vec == NULL)
 210     {
 211       if (fd != -1)
 212         close (fd);
 213       _bfd_delete_bfd (nbfd);
 214       return NULL;
 215     }
 216
 217 #ifdef HAVE_FDOPEN
 218   if (fd != -1)
 219     nbfd->iostream = fdopen (fd, mode);
 220   else
 221 #endif
 222     nbfd->iostream = _bfd_real_fopen (filename, mode);
 223   if (nbfd->iostream == NULL)
 224     {
 225       bfd_set_error (bfd_error_system_call);
 226       if (fd != -1)
 227         close (fd);
 228       _bfd_delete_bfd (nbfd);
 229       return NULL;
 230     }
 231
 232   /* OK, put everything where it belongs.  */
 233
 234   /* PR 11983: Do not cache the original filename, but
 235      rather make a copy - the original might go away.  */
 236   nbfd->filename = bfd_strdup (filename);
 237   if (nbfd->filename == NULL)
 238     {
 239       fclose (nbfd->iostream);
 240       _bfd_delete_bfd (nbfd);
 241       return NULL;
 242     }
 243
 244   /* Figure out whether the user is opening the file for reading,
 245      writing, or both, by looking at the MODE argument.  */
 246   if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')
 247       && mode[1] == '+')
 248     nbfd->direction = both_direction;
 249   else if (mode[0] == 'r')
 250     nbfd->direction = read_direction;
 251   else
 252     nbfd->direction = write_direction;
 253
 254   if (!bfd_cache_init (nbfd))
 255     {
 256       fclose (nbfd->iostream);
 257       _bfd_delete_bfd (nbfd);
 258       return NULL;
 259     }
 260   nbfd->opened_once = TRUE;
 261
 262   /* If we opened the file by name, mark it cacheable; we can close it
 263      and reopen it later.  However, if a file descriptor was provided,
 264      then it may have been opened with special flags that make it
 265      unsafe to close and reopen the file.  */
 266   if (fd == -1)
 267     (void) bfd_set_cacheable (nbfd, TRUE);
 268
 269   return nbfd;
 270 }
 271
 272 /*
 273 FUNCTION
 274         bfd_openr
 275
 276 SYNOPSIS
 277         bfd *bfd_openr (const char *filename, const char *target);
 278
 279 DESCRIPTION
 280         Open the file @var{filename} (using <<fopen>>) with the target
 281         @var{target}.  Return a pointer to the created BFD.
 282
 283         Calls <<bfd_find_target>>, so @var{target} is interpreted as by
 284         that function.
 285
 286         If <<NULL>> is returned then an error has occured.   Possible errors
 287         are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
 288         <<system_call>> error.
 289
 290         A copy of the @var{filename} argument is stored in the newly created
 291         BFD.  It can be accessed via the bfd_get_filename() macro.
 292 */
 293
 294 bfd *
 295 bfd_openr (const char *filename, const char *target)
 296 {
 297   return bfd_fopen (filename, target, FOPEN_RB, -1);
 298 }
 299
 300 /* Don't try to `optimize' this function:
 301
 302    o - We lock using stack space so that interrupting the locking
 303        won't cause a storage leak.
 304    o - We open the file stream last, since we don't want to have to
 305        close it if anything goes wrong.  Closing the stream means closing
 306        the file descriptor too, even though we didn't open it.  */
 307 /*
 308 FUNCTION
 309         bfd_fdopenr
 310
 311 SYNOPSIS
 312         bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
 313
 314 DESCRIPTION
 315         <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
 316         <<fopen>>.  It opens a BFD on a file already described by the
 317         @var{fd} supplied.
 318
 319         When the file is later <<bfd_close>>d, the file descriptor will
 320         be closed.  If the caller desires that this file descriptor be
 321         cached by BFD (opened as needed, closed as needed to free
 322         descriptors for other opens), with the supplied @var{fd} used as
 323         an initial file descriptor (but subject to closure at any time),
 324         call bfd_set_cacheable(bfd, 1) on the returned BFD.  The default
 325         is to assume no caching; the file descriptor will remain open
 326         until <<bfd_close>>, and will not be affected by BFD operations
 327         on other files.
 328
 329         Possible errors are <<bfd_error_no_memory>>,
 330         <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
 331
 332         On error, @var{fd} is closed.
 333
 334         A copy of the @var{filename} argument is stored in the newly created
 335         BFD.  It can be accessed via the bfd_get_filename() macro.
 336 */
 337
 338 bfd *
 339 bfd_fdopenr (const char *filename, const char *target, int fd)
 340 {
 341   const char *mode;
 342 #if defined(HAVE_FCNTL) && defined(F_GETFL)
 343   int fdflags;
 344 #endif
 345
 346 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
 347   mode = FOPEN_RUB; /* Assume full access.  */
 348 #else
 349   fdflags = fcntl (fd, F_GETFL, NULL);
 350   if (fdflags == -1)
 351     {
 352       int save = errno;
 353
 354       close (fd);
 355       errno = save;
 356       bfd_set_error (bfd_error_system_call);
 357       return NULL;
 358     }
 359
 360   /* (O_ACCMODE) parens are to avoid Ultrix header file bug.  */
 361   switch (fdflags & (O_ACCMODE))
 362     {
 363     case O_RDONLY: mode = FOPEN_RB; break;
 364     case O_WRONLY: mode = FOPEN_RUB; break;
 365     case O_RDWR:   mode = FOPEN_RUB; break;
 366     default: abort ();
 367     }
 368 #endif
 369
 370   return bfd_fopen (filename, target, mode, fd);
 371 }
 372
 373 /*
 374 FUNCTION
 375         bfd_openstreamr
 376
 377 SYNOPSIS
 378         bfd *bfd_openstreamr (const char * filename, const char * target,
 379                               void * stream);
 380
 381 DESCRIPTION
 382         Open a BFD for read access on an existing stdio stream.  When
 383         the BFD is passed to <<bfd_close>>, the stream will be closed.
 384
 385         A copy of the @var{filename} argument is stored in the newly created
 386         BFD.  It can be accessed via the bfd_get_filename() macro.
 387 */
 388
 389 bfd *
 390 bfd_openstreamr (const char *filename, const char *target, void *streamarg)
 391 {
 392   FILE *stream = (FILE *) streamarg;
 393   bfd *nbfd;
 394   const bfd_target *target_vec;
 395
 396   nbfd = _bfd_new_bfd ();
 397   if (nbfd == NULL)
 398     return NULL;
 399
 400   target_vec = bfd_find_target (target, nbfd);
 401   if (target_vec == NULL)
 402     {
 403       _bfd_delete_bfd (nbfd);
 404       return NULL;
 405     }
 406
 407   nbfd->iostream = stream;
 408   /* PR 11983: Do not cache the original filename, but
 409      rather make a copy - the original might go away.  */
 410   nbfd->filename = bfd_strdup (filename);
 411   if (nbfd->filename == NULL)
 412     {
 413       _bfd_delete_bfd (nbfd);
 414       return NULL;
 415     }
 416   nbfd->direction = read_direction;
 417
 418   if (! bfd_cache_init (nbfd))
 419     {
 420       _bfd_delete_bfd (nbfd);
 421       return NULL;
 422     }
 423
 424   return nbfd;
 425 }
 426
 427 /*
 428 FUNCTION
 429         bfd_openr_iovec
 430
 431 SYNOPSIS
 432         bfd *bfd_openr_iovec (const char *filename, const char *target,
 433                               void *(*open_func) (struct bfd *nbfd,
 434                                                   void *open_closure),
 435                               void *open_closure,
 436                               file_ptr (*pread_func) (struct bfd *nbfd,
 437                                                       void *stream,
 438                                                       void *buf,
 439                                                       file_ptr nbytes,
 440                                                       file_ptr offset),
 441                               int (*close_func) (struct bfd *nbfd,
 442                                                  void *stream),
 443                               int (*stat_func) (struct bfd *abfd,
 444                                                 void *stream,
 445                                                 struct stat *sb));
 446
 447 DESCRIPTION
 448         Create and return a BFD backed by a read-only @var{stream}.
 449         The @var{stream} is created using @var{open_func}, accessed using
 450         @var{pread_func} and destroyed using @var{close_func}.
 451
 452         Calls <<bfd_find_target>>, so @var{target} is interpreted as by
 453         that function.
 454
 455         Calls @var{open_func} (which can call <<bfd_zalloc>> and
 456         <<bfd_get_filename>>) to obtain the read-only stream backing
 457         the BFD.  @var{open_func} either succeeds returning the
 458         non-<<NULL>> @var{stream}, or fails returning <<NULL>>
 459         (setting <<bfd_error>>).
 460
 461         Calls @var{pread_func} to request @var{nbytes} of data from
 462         @var{stream} starting at @var{offset} (e.g., via a call to
 463         <<bfd_read>>).  @var{pread_func} either succeeds returning the
 464         number of bytes read (which can be less than @var{nbytes} when
 465         end-of-file), or fails returning -1 (setting <<bfd_error>>).
 466
 467         Calls @var{close_func} when the BFD is later closed using
 468         <<bfd_close>>.  @var{close_func} either succeeds returning 0, or
 469         fails returning -1 (setting <<bfd_error>>).
 470
 471         Calls @var{stat_func} to fill in a stat structure for bfd_stat,
 472         bfd_get_size, and bfd_get_mtime calls.  @var{stat_func} returns 0
 473         on success, or returns -1 on failure (setting <<bfd_error>>).
 474
 475         If <<bfd_openr_iovec>> returns <<NULL>> then an error has
 476         occurred.  Possible errors are <<bfd_error_no_memory>>,
 477         <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
 478
 479         A copy of the @var{filename} argument is stored in the newly created
 480         BFD.  It can be accessed via the bfd_get_filename() macro.
 481 */
 482
 483 struct opncls
 484 {
 485   void *stream;
 486   file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,
 487                      file_ptr nbytes, file_ptr offset);
 488   int (*close) (struct bfd *abfd, void *stream);
 489   int (*stat) (struct bfd *abfd, void *stream, struct stat *sb);
 490   file_ptr where;
 491 };
 492
 493 static file_ptr
 494 opncls_btell (struct bfd *abfd)
 495 {
 496   struct opncls *vec = (struct opncls *) abfd->iostream;
 497   return vec->where;
 498 }
 499
 500 static int
 501 opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)
 502 {
 503   struct opncls *vec = (struct opncls *) abfd->iostream;
 504   switch (whence)
 505     {
 506     case SEEK_SET: vec->where = offset; break;
 507     case SEEK_CUR: vec->where += offset; break;
 508     case SEEK_END: return -1;
 509     }
 510   return 0;
 511 }
 512
 513 static file_ptr
 514 opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
 515 {
 516   struct opncls *vec = (struct opncls *) abfd->iostream;
 517   file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where);
 518
 519   if (nread < 0)
 520     return nread;
 521   vec->where += nread;
 522   return nread;
 523 }
 524
 525 static file_ptr
 526 opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
 527               const void *where ATTRIBUTE_UNUSED,
 528               file_ptr nbytes ATTRIBUTE_UNUSED)
 529 {
 530   return -1;
 531 }
 532
 533 static int
 534 opncls_bclose (struct bfd *abfd)
 535 {
 536   struct opncls *vec = (struct opncls *) abfd->iostream;
 537   /* Since the VEC's memory is bound to the bfd deleting the bfd will
 538      free it.  */
 539   int status = 0;
 540
 541   if (vec->close != NULL)
 542     status = (vec->close) (abfd, vec->stream);
 543   abfd->iostream = NULL;
 544   return status;
 545 }
 546
 547 static int
 548 opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
 549 {
 550   return 0;
 551 }
 552
 553 static int
 554 opncls_bstat (struct bfd *abfd, struct stat *sb)
 555 {
 556   struct opncls *vec = (struct opncls *) abfd->iostream;
 557
 558   memset (sb, 0, sizeof (*sb));
 559   if (vec->stat == NULL)
 560     return 0;
 561
 562   return (vec->stat) (abfd, vec->stream, sb);
 563 }
 564
 565 static void *
 566 opncls_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
 567               void *addr ATTRIBUTE_UNUSED,
 568               bfd_size_type len ATTRIBUTE_UNUSED,
 569               int prot ATTRIBUTE_UNUSED,
 570               int flags ATTRIBUTE_UNUSED,
 571               file_ptr offset ATTRIBUTE_UNUSED,
 572               void **map_addr ATTRIBUTE_UNUSED,
 573               bfd_size_type *map_len ATTRIBUTE_UNUSED)
 574 {
 575   return (void *) -1;
 576 }
 577
 578 static const struct bfd_iovec opncls_iovec =
 579 {
 580   &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
 581   &opncls_bclose, &opncls_bflush, &opncls_bstat, &opncls_bmmap
 582 };
 583
 584 bfd *
 585 bfd_openr_iovec (const char *filename, const char *target,
 586                  void *(*open_p) (struct bfd *, void *),
 587                  void *open_closure,
 588                  file_ptr (*pread_p) (struct bfd *, void *, void *,
 589                                       file_ptr, file_ptr),
 590                  int (*close_p) (struct bfd *, void *),
 591                  int (*stat_p) (struct bfd *, void *, struct stat *))
 592 {
 593   bfd *nbfd;
 594   const bfd_target *target_vec;
 595   struct opncls *vec;
 596   void *stream;
 597
 598   nbfd = _bfd_new_bfd ();
 599   if (nbfd == NULL)
 600     return NULL;
 601
 602   target_vec = bfd_find_target (target, nbfd);
 603   if (target_vec == NULL)
 604     {
 605       _bfd_delete_bfd (nbfd);
 606       return NULL;
 607     }
 608
 609   /* PR 11983: Do not cache the original filename, but
 610      rather make a copy - the original might go away.  */
 611   nbfd->filename = bfd_strdup (filename);
 612   if (nbfd->filename == NULL)
 613     {
 614       _bfd_delete_bfd (nbfd);
 615       return NULL;
 616     }
 617   nbfd->direction = read_direction;
 618
 619   /* `open_p (...)' would get expanded by an the open(2) syscall macro.  */
 620   stream = (*open_p) (nbfd, open_closure);
 621   if (stream == NULL)
 622     {
 623       _bfd_delete_bfd (nbfd);
 624       return NULL;
 625     }
 626
 627   vec = (struct opncls *) bfd_zalloc (nbfd, sizeof (struct opncls));
 628   vec->stream = stream;
 629   vec->pread = pread_p;
 630   vec->close = close_p;
 631   vec->stat = stat_p;
 632
 633   nbfd->iovec = &opncls_iovec;
 634   nbfd->iostream = vec;
 635
 636   return nbfd;
 637 }
 638 \f
 639 /* bfd_openw -- open for writing.
 640    Returns a pointer to a freshly-allocated BFD on success, or NULL.
 641
 642    See comment by bfd_fdopenr before you try to modify this function.  */
 643
 644 /*
 645 FUNCTION
 646         bfd_openw
 647
 648 SYNOPSIS
 649         bfd *bfd_openw (const char *filename, const char *target);
 650
 651 DESCRIPTION
 652         Create a BFD, associated with file @var{filename}, using the
 653         file format @var{target}, and return a pointer to it.
 654
 655         Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
 656         <<bfd_error_invalid_target>>.
 657
 658         A copy of the @var{filename} argument is stored in the newly created
 659         BFD.  It can be accessed via the bfd_get_filename() macro.
 660 */
 661
 662 bfd *
 663 bfd_openw (const char *filename, const char *target)
 664 {
 665   bfd *nbfd;
 666   const bfd_target *target_vec;
 667
 668   /* nbfd has to point to head of malloc'ed block so that bfd_close may
 669      reclaim it correctly.  */
 670   nbfd = _bfd_new_bfd ();
 671   if (nbfd == NULL)
 672     return NULL;
 673
 674   target_vec = bfd_find_target (target, nbfd);
 675   if (target_vec == NULL)
 676     {
 677       _bfd_delete_bfd (nbfd);
 678       return NULL;
 679     }
 680
 681   /* PR 11983: Do not cache the original filename, but
 682      rather make a copy - the original might go away.  */
 683   nbfd->filename = bfd_strdup (filename);
 684   if (nbfd->filename == NULL)
 685     {
 686       _bfd_delete_bfd (nbfd);
 687       return NULL;
 688     }
 689   nbfd->direction = write_direction;
 690
 691   if (bfd_open_file (nbfd) == NULL)
 692     {
 693       /* File not writeable, etc.  */
 694       bfd_set_error (bfd_error_system_call);
 695       _bfd_delete_bfd (nbfd);
 696       return NULL;
 697   }
 698
 699   return nbfd;
 700 }
 701
 702 static inline void
 703 _maybe_make_executable (bfd * abfd)
 704 {
 705   /* If the file was open for writing and is now executable,
 706      make it so.  */
 707   if (abfd->direction == write_direction
 708       && (abfd->flags & (EXEC_P | DYNAMIC)) != 0)
 709     {
 710       struct stat buf;
 711
 712       if (stat (abfd->filename, &buf) == 0
 713           /* Do not attempt to change non-regular files.  This is
 714              here especially for configure scripts and kernel builds
 715              which run tests with "ld [...] -o /dev/null".  */
 716           && S_ISREG(buf.st_mode))
 717         {
 718           unsigned int mask = umask (0);
 719
 720           umask (mask);
 721           chmod (abfd->filename,
 722                  (0777
 723                   & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
 724         }
 725     }
 726 }
 727
 728 /*
 729 FUNCTION
 730         bfd_close
 731
 732 SYNOPSIS
 733         bfd_boolean bfd_close (bfd *abfd);
 734
 735 DESCRIPTION
 736         Close a BFD. If the BFD was open for writing, then pending
 737         operations are completed and the file written out and closed.
 738         If the created file is executable, then <<chmod>> is called
 739         to mark it as such.
 740
 741         All memory attached to the BFD is released.
 742
 743         The file descriptor associated with the BFD is closed (even
 744         if it was passed in to BFD by <<bfd_fdopenr>>).
 745
 746 RETURNS
 747         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 748 */
 749
 750 bfd_boolean
 751 bfd_close (bfd *abfd)
 752 {
 753   if (bfd_write_p (abfd))
 754     {
 755       if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 756         return FALSE;
 757     }
 758
 759   return bfd_close_all_done (abfd);
 760 }
 761
 762 /*
 763 FUNCTION
 764         bfd_close_all_done
 765
 766 SYNOPSIS
 767         bfd_boolean bfd_close_all_done (bfd *);
 768
 769 DESCRIPTION
 770         Close a BFD.  Differs from <<bfd_close>> since it does not
 771         complete any pending operations.  This routine would be used
 772         if the application had just used BFD for swapping and didn't
 773         want to use any of the writing code.
 774
 775         If the created file is executable, then <<chmod>> is called
 776         to mark it as such.
 777
 778         All memory attached to the BFD is released.
 779
 780 RETURNS
 781         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 782 */
 783
 784 bfd_boolean
 785 bfd_close_all_done (bfd *abfd)
 786 {
 787   bfd_boolean ret;
 788
 789   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 790     return FALSE;
 791
 792   ret = abfd->iovec->bclose (abfd) == 0;
 793
 794   if (ret)
 795     _maybe_make_executable (abfd);
 796
 797   _bfd_delete_bfd (abfd);
 798
 799   return ret;
 800 }
 801
 802 /*
 803 FUNCTION
 804         bfd_create
 805
 806 SYNOPSIS
 807         bfd *bfd_create (const char *filename, bfd *templ);
 808
 809 DESCRIPTION
 810         Create a new BFD in the manner of <<bfd_openw>>, but without
 811         opening a file. The new BFD takes the target from the target
 812         used by @var{templ}. The format is always set to <<bfd_object>>.
 813
 814         A copy of the @var{filename} argument is stored in the newly created
 815         BFD.  It can be accessed via the bfd_get_filename() macro.
 816 */
 817
 818 bfd *
 819 bfd_create (const char *filename, bfd *templ)
 820 {
 821   bfd *nbfd;
 822
 823   nbfd = _bfd_new_bfd ();
 824   if (nbfd == NULL)
 825     return NULL;
 826   /* PR 11983: Do not cache the original filename, but
 827      rather make a copy - the original might go away.  */
 828   nbfd->filename = bfd_strdup (filename);
 829   if (nbfd->filename == NULL)
 830     {
 831       _bfd_delete_bfd (nbfd);
 832       return NULL;
 833     }
 834   if (templ)
 835     nbfd->xvec = templ->xvec;
 836   nbfd->direction = no_direction;
 837   bfd_set_format (nbfd, bfd_object);
 838
 839   return nbfd;
 840 }
 841
 842 /*
 843 FUNCTION
 844         bfd_make_writable
 845
 846 SYNOPSIS
 847         bfd_boolean bfd_make_writable (bfd *abfd);
 848
 849 DESCRIPTION
 850         Takes a BFD as created by <<bfd_create>> and converts it
 851         into one like as returned by <<bfd_openw>>.  It does this
 852         by converting the BFD to BFD_IN_MEMORY.  It's assumed that
 853         you will call <<bfd_make_readable>> on this bfd later.
 854
 855 RETURNS
 856         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 857 */
 858
 859 bfd_boolean
 860 bfd_make_writable (bfd *abfd)
 861 {
 862   struct bfd_in_memory *bim;
 863
 864   if (abfd->direction != no_direction)
 865     {
 866       bfd_set_error (bfd_error_invalid_operation);
 867       return FALSE;
 868     }
 869
 870   bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
 871   if (bim == NULL)
 872     return FALSE;       /* bfd_error already set.  */
 873   abfd->iostream = bim;
 874   /* bfd_bwrite will grow these as needed.  */
 875   bim->size = 0;
 876   bim->buffer = 0;
 877
 878   abfd->flags |= BFD_IN_MEMORY;
 879   abfd->iovec = &_bfd_memory_iovec;
 880   abfd->origin = 0;
 881   abfd->direction = write_direction;
 882   abfd->where = 0;
 883
 884   return TRUE;
 885 }
 886
 887 /*
 888 FUNCTION
 889         bfd_make_readable
 890
 891 SYNOPSIS
 892         bfd_boolean bfd_make_readable (bfd *abfd);
 893
 894 DESCRIPTION
 895         Takes a BFD as created by <<bfd_create>> and
 896         <<bfd_make_writable>> and converts it into one like as
 897         returned by <<bfd_openr>>.  It does this by writing the
 898         contents out to the memory buffer, then reversing the
 899         direction.
 900
 901 RETURNS
 902         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
 903
 904 bfd_boolean
 905 bfd_make_readable (bfd *abfd)
 906 {
 907   if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
 908     {
 909       bfd_set_error (bfd_error_invalid_operation);
 910       return FALSE;
 911     }
 912
 913   if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 914     return FALSE;
 915
 916   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 917     return FALSE;
 918
 919   abfd->arch_info = &bfd_default_arch_struct;
 920
 921   abfd->where = 0;
 922   abfd->format = bfd_unknown;
 923   abfd->my_archive = NULL;
 924   abfd->origin = 0;
 925   abfd->opened_once = FALSE;
 926   abfd->output_has_begun = FALSE;
 927   abfd->section_count = 0;
 928   abfd->usrdata = NULL;
 929   abfd->cacheable = FALSE;
 930   abfd->flags |= BFD_IN_MEMORY;
 931   abfd->mtime_set = FALSE;
 932
 933   abfd->target_defaulted = TRUE;
 934   abfd->direction = read_direction;
 935   abfd->sections = 0;
 936   abfd->symcount = 0;
 937   abfd->outsymbols = 0;
 938   abfd->tdata.any = 0;
 939
 940   bfd_section_list_clear (abfd);
 941   bfd_check_format (abfd, bfd_object);
 942
 943   return TRUE;
 944 }
 945
 946 /*
 947 FUNCTION
 948         bfd_alloc
 949
 950 SYNOPSIS
 951         void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
 952
 953 DESCRIPTION
 954         Allocate a block of @var{wanted} bytes of memory attached to
 955         <<abfd>> and return a pointer to it.
 956 */
 957
 958 void *
 959 bfd_alloc (bfd *abfd, bfd_size_type size)
 960 {
 961   void *ret;
 962   unsigned long ul_size = (unsigned long) size;
 963
 964   if (size != ul_size
 965       /* Note - although objalloc_alloc takes an unsigned long as its
 966          argument, internally the size is treated as a signed long.  This can
 967          lead to problems where, for example, a request to allocate -1 bytes
 968          can result in just 1 byte being allocated, rather than
 969          ((unsigned long) -1) bytes.  Also memory checkers will often
 970          complain about attempts to allocate a negative amount of memory.
 971          So to stop these problems we fail if the size is negative.  */
 972       || ((signed long) ul_size) < 0)
 973     {
 974       bfd_set_error (bfd_error_no_memory);
 975       return NULL;
 976     }
 977
 978   ret = objalloc_alloc ((struct objalloc *) abfd->memory, ul_size);
 979   if (ret == NULL)
 980     bfd_set_error (bfd_error_no_memory);
 981   return ret;
 982 }
 983
 984 /*
 985 FUNCTION
 986         bfd_zalloc
 987
 988 SYNOPSIS
 989         void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
 990
 991 DESCRIPTION
 992         Allocate a block of @var{wanted} bytes of zeroed memory
 993         attached to <<abfd>> and return a pointer to it.
 994 */
 995
 996 void *
 997 bfd_zalloc (bfd *abfd, bfd_size_type size)
 998 {
 999   void *res;
1000
1001   res = bfd_alloc (abfd, size);
1002   if (res)
1003     memset (res, 0, (size_t) size);
1004   return res;
1005 }
1006
1007 /* Free a block allocated for a BFD.
1008    Note:  Also frees all more recently allocated blocks!  */
1009
1010 void
1011 bfd_release (bfd *abfd, void *block)
1012 {
1013   objalloc_free_block ((struct objalloc *) abfd->memory, block);
1014 }
1015
1016
1017 /*
1018    GNU Extension: separate debug-info files
1019
1020    The idea here is that a special section called .gnu_debuglink might be
1021    embedded in a binary file, which indicates that some *other* file
1022    contains the real debugging information. This special section contains a
1023    filename and CRC32 checksum, which we read and resolve to another file,
1024    if it exists.
1025
1026    This facilitates "optional" provision of debugging information, without
1027    having to provide two complete copies of every binary object (with and
1028    without debug symbols).  */
1029
1030 #define GNU_DEBUGLINK           ".gnu_debuglink"
1031 #define GNU_DEBUGALTLINK        ".gnu_debugaltlink"
1032
1033 /*
1034 FUNCTION
1035         bfd_calc_gnu_debuglink_crc32
1036
1037 SYNOPSIS
1038         unsigned long bfd_calc_gnu_debuglink_crc32
1039           (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1040
1041 DESCRIPTION
1042         Computes a CRC value as used in the .gnu_debuglink section.
1043         Advances the previously computed @var{crc} value by computing
1044         and adding in the crc32 for @var{len} bytes of @var{buf}.
1045
1046 RETURNS
1047         Return the updated CRC32 value.
1048 */
1049
1050 unsigned long
1051 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1052                               const unsigned char *buf,
1053                               bfd_size_type len)
1054 {
1055   static const unsigned long crc32_table[256] =
1056     {
1057       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1058       0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1059       0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1060       0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1061       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1062       0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1063       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1064       0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1065       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1066       0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1067       0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1068       0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1069       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1070       0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1071       0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1072       0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1073       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1074       0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1075       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1076       0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1077       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1078       0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1079       0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1080       0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1081       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1082       0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1083       0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1084       0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1085       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1086       0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1087       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1088       0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1089       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1090       0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1091       0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1092       0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1093       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1094       0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1095       0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1096       0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1097       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1098       0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1099       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1100       0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1101       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1102       0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1103       0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1104       0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1105       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1106       0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1107       0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1108       0x2d02ef8d
1109     };
1110   const unsigned char *end;
1111
1112   crc = ~crc & 0xffffffff;
1113   for (end = buf + len; buf < end; ++ buf)
1114     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1115   return ~crc & 0xffffffff;
1116 }
1117
1118
1119 /*
1120 INTERNAL_FUNCTION
1121         bfd_get_debug_link_info_1
1122
1123 SYNOPSIS
1124         char *bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out);
1125
1126 DESCRIPTION
1127         Extracts the filename and CRC32 value for any separate debug
1128         information file associated with @var{abfd}.
1129
1130         The @var{crc32_out} parameter is an untyped pointer because
1131         this routine is used as a @code{get_func_type} function, but it
1132         is expected to be an unsigned long pointer.
1133
1134 RETURNS
1135         The filename of the associated debug information file, or NULL
1136         if there is no such file.  If the filename was found then the
1137         contents of @var{crc32_out} are updated to hold the corresponding
1138         CRC32 value for the file.
1139
1140         The returned filename is allocated with @code{malloc}; freeing
1141         it is the responsibility of the caller.
1142 */
1143
1144 static char *
1145 bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out)
1146 {
1147   asection *sect;
1148   unsigned long *crc32 = (unsigned long *) crc32_out;
1149   bfd_byte *contents;
1150   unsigned int crc_offset;
1151   char *name;
1152   bfd_size_type size;
1153   ufile_ptr file_size;
1154
1155   BFD_ASSERT (abfd);
1156   BFD_ASSERT (crc32_out);
1157
1158   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1159
1160   if (sect == NULL)
1161     return NULL;
1162
1163   size = bfd_section_size (sect);
1164   file_size = bfd_get_size (abfd);
1165
1166   /* PR 22794: Make sure that the section has a reasonable size.  */
1167   if (size < 8 || (file_size != 0 && size >= file_size))
1168     return NULL;
1169
1170   if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1171     {
1172       if (contents != NULL)
1173         free (contents);
1174       return NULL;
1175     }
1176
1177   /* CRC value is stored after the filename, aligned up to 4 bytes.  */
1178   name = (char *) contents;
1179   /* PR 17597: Avoid reading off the end of the buffer.  */
1180   crc_offset = strnlen (name, size) + 1;
1181   crc_offset = (crc_offset + 3) & ~3;
1182   if (crc_offset + 4 > size)
1183     return NULL;
1184
1185   *crc32 = bfd_get_32 (abfd, contents + crc_offset);
1186   return name;
1187 }
1188
1189
1190 /*
1191 FUNCTION
1192         bfd_get_debug_link_info
1193
1194 SYNOPSIS
1195         char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1196
1197 DESCRIPTION
1198         Extracts the filename and CRC32 value for any separate debug
1199         information file associated with @var{abfd}.
1200
1201 RETURNS
1202         The filename of the associated debug information file, or NULL
1203         if there is no such file.  If the filename was found then the
1204         contents of @var{crc32_out} are updated to hold the corresponding
1205         CRC32 value for the file.
1206
1207         The returned filename is allocated with @code{malloc}; freeing
1208         it is the responsibility of the caller.
1209 */
1210
1211 char *
1212 bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1213 {
1214   return bfd_get_debug_link_info_1 (abfd, crc32_out);
1215 }
1216
1217 /*
1218 FUNCTION
1219         bfd_get_alt_debug_link_info
1220
1221 SYNOPSIS
1222         char *bfd_get_alt_debug_link_info (bfd * abfd,
1223                                            bfd_size_type *buildid_len,
1224                                            bfd_byte **buildid_out);
1225
1226 DESCRIPTION
1227         Fetch the filename and BuildID value for any alternate debuginfo
1228         associated with @var{abfd}.  Return NULL if no such info found,
1229         otherwise return filename and update @var{buildid_len} and
1230         @var{buildid_out}.  The returned filename and build_id are
1231         allocated with @code{malloc}; freeing them is the responsibility
1232         of the caller.
1233 */
1234
1235 char *
1236 bfd_get_alt_debug_link_info (bfd * abfd, bfd_size_type *buildid_len,
1237                              bfd_byte **buildid_out)
1238 {
1239   asection *sect;
1240   bfd_byte *contents;
1241   unsigned int buildid_offset;
1242   char *name;
1243   bfd_size_type size;
1244   ufile_ptr file_size;
1245
1246   BFD_ASSERT (abfd);
1247   BFD_ASSERT (buildid_len);
1248   BFD_ASSERT (buildid_out);
1249
1250   sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK);
1251
1252   if (sect == NULL)
1253     return NULL;
1254
1255   size = bfd_section_size (sect);
1256   file_size = bfd_get_size (abfd);
1257   if (size < 8 || (file_size != 0 && size >= file_size))
1258     return NULL;
1259
1260   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1261     {
1262       if (contents != NULL)
1263         free (contents);
1264       return NULL;
1265     }
1266
1267   /* BuildID value is stored after the filename.  */
1268   name = (char *) contents;
1269   buildid_offset = strnlen (name, size) + 1;
1270   if (buildid_offset >= bfd_section_size (sect))
1271     return NULL;
1272
1273   *buildid_len = size - buildid_offset;
1274   *buildid_out = bfd_malloc (*buildid_len);
1275   memcpy (*buildid_out, contents + buildid_offset, *buildid_len);
1276
1277   return name;
1278 }
1279
1280 /*
1281 INTERNAL_FUNCTION
1282         separate_debug_file_exists
1283
1284 SYNOPSIS
1285         bfd_boolean separate_debug_file_exists
1286           (char *name, void *crc32_p);
1287
1288 DESCRIPTION
1289         Checks to see if @var{name} is a file and if its contents
1290         match @var{crc32}, which is a pointer to an @code{unsigned
1291         long} containing a CRC32.
1292
1293         The @var{crc32_p} parameter is an untyped pointer because
1294         this routine is used as a @code{check_func_type} function.
1295 */
1296
1297 static bfd_boolean
1298 separate_debug_file_exists (const char *name, void *crc32_p)
1299 {
1300   static unsigned char buffer [8 * 1024];
1301   unsigned long file_crc = 0;
1302   FILE *f;
1303   bfd_size_type count;
1304   unsigned long crc;
1305
1306   BFD_ASSERT (name);
1307   BFD_ASSERT (crc32_p);
1308
1309   crc = *(unsigned long *) crc32_p;
1310
1311   f = _bfd_real_fopen (name, FOPEN_RB);
1312   if (f == NULL)
1313     return FALSE;
1314
1315   while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1316     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1317
1318   fclose (f);
1319
1320   return crc == file_crc;
1321 }
1322
1323 /*
1324 INTERNAL_FUNCTION
1325         separate_alt_debug_file_exists
1326
1327 SYNOPSIS
1328         bfd_boolean separate_alt_debug_file_exists
1329           (char *name, void *unused);
1330
1331 DESCRIPTION
1332         Checks to see if @var{name} is a file.
1333 */
1334
1335 static bfd_boolean
1336 separate_alt_debug_file_exists (const char *name, void *unused ATTRIBUTE_UNUSED)
1337 {
1338   FILE *f;
1339
1340   BFD_ASSERT (name);
1341
1342   f = _bfd_real_fopen (name, FOPEN_RB);
1343   if (f == NULL)
1344     return FALSE;
1345
1346   fclose (f);
1347
1348   return TRUE;
1349 }
1350
1351 /*
1352 INTERNAL_FUNCTION
1353         find_separate_debug_file
1354
1355 SYNOPSIS
1356         char *find_separate_debug_file
1357           (bfd *abfd, const char *dir, bfd_boolean include_dirs,
1358            get_func_type get, check_func_type check, void *data);
1359
1360 DESCRIPTION
1361         Searches for a debug information file corresponding to @var{abfd}.
1362
1363         The name of the separate debug info file is returned by the
1364         @var{get} function.  This function scans various fixed locations
1365         in the filesystem, including the file tree rooted at @var{dir}.
1366         If the @var{include_dirs} parameter is true then the directory
1367         components of @var{abfd}'s filename will be included in the
1368         searched locations.
1369
1370         @var{data} is passed unmodified to the @var{get} and @var{check}
1371         functions.  It is generally used to implement build-id-like
1372         matching in the callback functions.
1373
1374 RETURNS
1375         Returns the filename of the first file to be found which
1376         receives a TRUE result from the @var{check} function.
1377         Returns NULL if no valid file could be found.
1378 */
1379
1380 typedef char *      (* get_func_type) (bfd *, void *);
1381 typedef bfd_boolean (* check_func_type) (const char *, void *);
1382
1383 static char *
1384 find_separate_debug_file (bfd *           abfd,
1385                           const char *    debug_file_directory,
1386                           bfd_boolean     include_dirs,
1387                           get_func_type   get_func,
1388                           check_func_type check_func,
1389                           void *          func_data)
1390 {
1391   char *base;
1392   char *dir;
1393   char *debugfile;
1394   char *canon_dir;
1395   size_t dirlen;
1396   size_t canon_dirlen;
1397
1398   BFD_ASSERT (abfd);
1399   if (debug_file_directory == NULL)
1400     debug_file_directory = ".";
1401
1402   /* BFD may have been opened from a stream.  */
1403   if (abfd->filename == NULL)
1404     {
1405       bfd_set_error (bfd_error_invalid_operation);
1406       return NULL;
1407     }
1408
1409   base = get_func (abfd, func_data);
1410
1411   if (base == NULL)
1412     return NULL;
1413
1414   if (base[0] == '\0')
1415     {
1416       free (base);
1417       bfd_set_error (bfd_error_no_debug_section);
1418       return NULL;
1419     }
1420
1421   if (include_dirs)
1422     {
1423       for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--)
1424         if (IS_DIR_SEPARATOR (abfd->filename[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, abfd->filename, 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 (abfd->filename);
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 || abfd->filename == 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 }