bfd/opncls.c

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