bfd/opncls.c

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