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