bfd/opncls.c

   1 /* opncls.c -- open and close a BFD.
   2    Copyright (C) 1990-2018 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   bfd_size_type size;
1183
1184   BFD_ASSERT (abfd);
1185   BFD_ASSERT (crc32_out);
1186
1187   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1188
1189   if (sect == NULL)
1190     return NULL;
1191
1192   size = bfd_get_section_size (sect);
1193
1194   /* PR 22794: Make sure that the section has a reasonable size.  */
1195   if (size < 8 || size >= bfd_get_size (abfd))
1196     return NULL;
1197
1198   if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1199     {
1200       if (contents != NULL)
1201         free (contents);
1202       return NULL;
1203     }
1204
1205   /* CRC value is stored after the filename, aligned up to 4 bytes.  */
1206   name = (char *) contents;
1207   /* PR 17597: Avoid reading off the end of the buffer.  */
1208   crc_offset = strnlen (name, size) + 1;
1209   crc_offset = (crc_offset + 3) & ~3;
1210   if (crc_offset + 4 > size)
1211     return NULL;
1212
1213   *crc32 = bfd_get_32 (abfd, contents + crc_offset);
1214   return name;
1215 }
1216
1217
1218 /*
1219 FUNCTION
1220         bfd_get_debug_link_info
1221
1222 SYNOPSIS
1223         char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1224
1225 DESCRIPTION
1226         Extracts the filename and CRC32 value for any separate debug
1227         information file associated with @var{abfd}.
1228
1229 RETURNS
1230         The filename of the associated debug information file, or NULL
1231         if there is no such file.  If the filename was found then the
1232         contents of @var{crc32_out} are updated to hold the corresponding
1233         CRC32 value for the file.
1234
1235         The returned filename is allocated with @code{malloc}; freeing
1236         it is the responsibility of the caller.
1237 */
1238
1239 char *
1240 bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1241 {
1242   return bfd_get_debug_link_info_1 (abfd, crc32_out);
1243 }
1244
1245 /*
1246 FUNCTION
1247         bfd_get_alt_debug_link_info
1248
1249 SYNOPSIS
1250         char *bfd_get_alt_debug_link_info (bfd * abfd,
1251                                            bfd_size_type *buildid_len,
1252                                            bfd_byte **buildid_out);
1253
1254 DESCRIPTION
1255         Fetch the filename and BuildID value for any alternate debuginfo
1256         associated with @var{abfd}.  Return NULL if no such info found,
1257         otherwise return filename and update @var{buildid_len} and
1258         @var{buildid_out}.  The returned filename and build_id are
1259         allocated with @code{malloc}; freeing them is the responsibility
1260         of the caller.
1261 */
1262
1263 char *
1264 bfd_get_alt_debug_link_info (bfd * abfd, bfd_size_type *buildid_len,
1265                              bfd_byte **buildid_out)
1266 {
1267   asection *sect;
1268   bfd_byte *contents;
1269   unsigned int buildid_offset;
1270   char *name;
1271   bfd_size_type size;
1272
1273   BFD_ASSERT (abfd);
1274   BFD_ASSERT (buildid_len);
1275   BFD_ASSERT (buildid_out);
1276
1277   sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK);
1278
1279   if (sect == NULL)
1280     return NULL;
1281
1282   size = bfd_get_section_size (sect);
1283   if (size < 8 || size >= bfd_get_size (abfd))
1284     return NULL;
1285
1286   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1287     {
1288       if (contents != NULL)
1289         free (contents);
1290       return NULL;
1291     }
1292
1293   /* BuildID value is stored after the filename.  */
1294   name = (char *) contents;
1295   buildid_offset = strnlen (name, size) + 1;
1296   if (buildid_offset >= bfd_get_section_size (sect))
1297     return NULL;
1298
1299   *buildid_len = size - buildid_offset;
1300   *buildid_out = bfd_malloc (*buildid_len);
1301   memcpy (*buildid_out, contents + buildid_offset, *buildid_len);
1302
1303   return name;
1304 }
1305
1306 /*
1307 INTERNAL_FUNCTION
1308         separate_debug_file_exists
1309
1310 SYNOPSIS
1311         bfd_boolean separate_debug_file_exists
1312           (char *name, void *crc32_p);
1313
1314 DESCRIPTION
1315         Checks to see if @var{name} is a file and if its contents
1316         match @var{crc32}, which is a pointer to an @code{unsigned
1317         long} containing a CRC32.
1318
1319         The @var{crc32_p} parameter is an untyped pointer because
1320         this routine is used as a @code{check_func_type} function.
1321 */
1322
1323 static bfd_boolean
1324 separate_debug_file_exists (const char *name, void *crc32_p)
1325 {
1326   static unsigned char buffer [8 * 1024];
1327   unsigned long file_crc = 0;
1328   FILE *f;
1329   bfd_size_type count;
1330   unsigned long crc;
1331
1332   BFD_ASSERT (name);
1333   BFD_ASSERT (crc32_p);
1334
1335   crc = *(unsigned long *) crc32_p;
1336
1337   f = _bfd_real_fopen (name, FOPEN_RB);
1338   if (f == NULL)
1339     return FALSE;
1340
1341   while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1342     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1343
1344   fclose (f);
1345
1346   return crc == file_crc;
1347 }
1348
1349 /*
1350 INTERNAL_FUNCTION
1351         separate_alt_debug_file_exists
1352
1353 SYNOPSIS
1354         bfd_boolean separate_alt_debug_file_exists
1355           (char *name, void *unused);
1356
1357 DESCRIPTION
1358         Checks to see if @var{name} is a file.
1359 */
1360
1361 static bfd_boolean
1362 separate_alt_debug_file_exists (const char *name, void *unused ATTRIBUTE_UNUSED)
1363 {
1364   FILE *f;
1365
1366   BFD_ASSERT (name);
1367
1368   f = _bfd_real_fopen (name, FOPEN_RB);
1369   if (f == NULL)
1370     return FALSE;
1371
1372   fclose (f);
1373
1374   return TRUE;
1375 }
1376
1377 /*
1378 INTERNAL_FUNCTION
1379         find_separate_debug_file
1380
1381 SYNOPSIS
1382         char *find_separate_debug_file
1383           (bfd *abfd, const char *dir, bfd_boolean include_dirs,
1384            get_func_type get, check_func_type check, void *data);
1385
1386 DESCRIPTION
1387         Searches for a debug information file corresponding to @var{abfd}.
1388
1389         The name of the separate debug info file is returned by the
1390         @var{get} function.  This function scans various fixed locations
1391         in the filesystem, including the file tree rooted at @var{dir}.
1392         If the @var{include_dirs} parameter is true then the directory
1393         components of @var{abfd}'s filename will be included in the
1394         searched locations.
1395
1396         @var{data} is passed unmodified to the @var{get} and @var{check}
1397         functions.  It is generally used to implement build-id-like
1398         matching in the callback functions.
1399
1400 RETURNS
1401         Returns the filename of the first file to be found which
1402         receives a TRUE result from the @var{check} function.
1403         Returns NULL if no valid file could be found.
1404 */
1405
1406 typedef char *      (* get_func_type) (bfd *, void *);
1407 typedef bfd_boolean (* check_func_type) (const char *, void *);
1408
1409 static char *
1410 find_separate_debug_file (bfd *           abfd,
1411                           const char *    debug_file_directory,
1412                           bfd_boolean     include_dirs,
1413                           get_func_type   get_func,
1414                           check_func_type check_func,
1415                           void *          func_data)
1416 {
1417   char *base;
1418   char *dir;
1419   char *debugfile;
1420   char *canon_dir;
1421   size_t dirlen;
1422   size_t canon_dirlen;
1423
1424   BFD_ASSERT (abfd);
1425   if (debug_file_directory == NULL)
1426     debug_file_directory = ".";
1427
1428   /* BFD may have been opened from a stream.  */
1429   if (abfd->filename == NULL)
1430     {
1431       bfd_set_error (bfd_error_invalid_operation);
1432       return NULL;
1433     }
1434
1435   base = get_func (abfd, func_data);
1436
1437   if (base == NULL)
1438     return NULL;
1439
1440   if (base[0] == '\0')
1441     {
1442       free (base);
1443       bfd_set_error (bfd_error_no_debug_section);
1444       return NULL;
1445     }
1446
1447   if (include_dirs)
1448     {
1449       for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--)
1450         if (IS_DIR_SEPARATOR (abfd->filename[dirlen - 1]))
1451           break;
1452
1453       dir = (char *) bfd_malloc (dirlen + 1);
1454       if (dir == NULL)
1455         {
1456           free (base);
1457           return NULL;
1458         }
1459       memcpy (dir, abfd->filename, dirlen);
1460       dir[dirlen] = '\0';
1461     }
1462   else
1463     {
1464       dir = (char *) bfd_malloc (1);
1465       * dir = 0;
1466       dirlen = 0;
1467     }
1468
1469   /* Compute the canonical name of the bfd object with all symbolic links
1470      resolved, for use in the global debugfile directory.  */
1471   canon_dir = lrealpath (abfd->filename);
1472   for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1473     if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1474       break;
1475   canon_dir[canon_dirlen] = '\0';
1476
1477 #ifndef EXTRA_DEBUG_ROOT1
1478 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1479 #endif
1480 #ifndef EXTRA_DEBUG_ROOT2
1481 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1482 #endif
1483
1484   debugfile = (char *)
1485       bfd_malloc (strlen (debug_file_directory) + 1
1486                   + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1487                   + strlen (".debug/")
1488 #ifdef EXTRA_DEBUG_ROOT1
1489                   + strlen (EXTRA_DEBUG_ROOT1)
1490 #endif
1491 #ifdef EXTRA_DEBUG_ROOT2
1492                   + strlen (EXTRA_DEBUG_ROOT2)
1493 #endif
1494                   + strlen (base)
1495                   + 1);
1496   if (debugfile == NULL)
1497     goto found; /* Actually this returns NULL.  */
1498
1499   /* First try in the same directory as the original file.
1500
1501      FIXME: Strictly speaking if we are using the build-id method,
1502      (ie include_dirs == FALSE) then we should only check absolute
1503      paths, not relative ones like this one (and the next one).
1504      The check is left in however as this allows the binutils
1505      testsuite to exercise this feature without having to install
1506      a file into the root filesystem.  (See binutils/testsuite/
1507      binutils-all/objdump.exp for the test).  */
1508   sprintf (debugfile, "%s%s", dir, base);
1509   if (check_func (debugfile, func_data))
1510     goto found;
1511
1512   /* Then try in a subdirectory called .debug.  */
1513   sprintf (debugfile, "%s.debug/%s", dir, base);
1514   if (check_func (debugfile, func_data))
1515     goto found;
1516
1517 #ifdef EXTRA_DEBUG_ROOT1
1518   /* Try the first extra debug file root.  */
1519   sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT1,
1520            include_dirs ? canon_dir : "/", base);
1521   if (check_func (debugfile, func_data))
1522     goto found;
1523 #endif
1524
1525 #ifdef EXTRA_DEBUG_ROOT2
1526   /* Try the second extra debug file root.  */
1527   sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT2,
1528            include_dirs ? canon_dir : "/", base);
1529   if (check_func (debugfile, func_data))
1530     goto found;
1531 #endif
1532
1533   /* Then try in the global debugfile directory.  */
1534   strcpy (debugfile, debug_file_directory);
1535   dirlen = strlen (debug_file_directory) - 1;
1536   if (include_dirs)
1537     {
1538       if (dirlen > 0
1539           && debug_file_directory[dirlen] != '/'
1540           && canon_dir[0] != '/')
1541         strcat (debugfile, "/");
1542       strcat (debugfile, canon_dir);
1543     }
1544   else
1545     {
1546       if (dirlen > 0 && debug_file_directory[dirlen] != '/')
1547         strcat (debugfile, "/");
1548     }
1549   strcat (debugfile, base);
1550
1551   if (check_func (debugfile, func_data))
1552     goto found;
1553
1554   /* Failed to find the file.  */
1555   free (debugfile);
1556   debugfile = NULL;
1557
1558  found:
1559   free (base);
1560   free (dir);
1561   free (canon_dir);
1562   return debugfile;
1563 }
1564
1565 /*
1566 FUNCTION
1567         bfd_follow_gnu_debuglink
1568
1569 SYNOPSIS
1570         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1571
1572 DESCRIPTION
1573         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1574         section is found, it examines the section for the name and checksum
1575         of a '.debug' file containing auxiliary debugging information.  It
1576         then searches the filesystem for this .debug file in some standard
1577         locations, including the directory tree rooted at @var{dir}, and if
1578         found returns the full filename.
1579
1580         If @var{dir} is NULL, the search will take place starting at
1581         the current directory.
1582
1583 RETURNS
1584         <<NULL>> on any errors or failure to locate the .debug file,
1585         otherwise a pointer to a heap-allocated string containing the
1586         filename.  The caller is responsible for freeing this string.
1587 */
1588
1589 char *
1590 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1591 {
1592   unsigned long crc32;
1593
1594   return find_separate_debug_file (abfd, dir, TRUE,
1595                                    bfd_get_debug_link_info_1,
1596                                    separate_debug_file_exists, &crc32);
1597 }
1598
1599 /* Helper for bfd_follow_gnu_debugaltlink.  It just returns the name
1600    of the separate debug file.  */
1601
1602 static char *
1603 get_alt_debug_link_info_shim (bfd * abfd, void *unused ATTRIBUTE_UNUSED)
1604 {
1605   bfd_size_type len;
1606   bfd_byte *buildid = NULL;
1607   char *result = bfd_get_alt_debug_link_info (abfd, &len, &buildid);
1608
1609   free (buildid);
1610
1611   return result;
1612 }
1613
1614 /*
1615 FUNCTION
1616         bfd_follow_gnu_debugaltlink
1617
1618 SYNOPSIS
1619         char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1620
1621 DESCRIPTION
1622         Takes a BFD and searches it for a .gnu_debugaltlink section.  If this
1623         section is found, it examines the section for the name of a file
1624         containing auxiliary debugging information.  It then searches the
1625         filesystem for this file in a set of standard locations, including
1626         the directory tree rooted at @var{dir}, and if found returns the
1627         full filename.
1628
1629         If @var{dir} is NULL, the search will take place starting at
1630         the current directory.
1631
1632 RETURNS
1633         <<NULL>> on any errors or failure to locate the debug file,
1634         otherwise a pointer to a heap-allocated string containing the
1635         filename.  The caller is responsible for freeing this string.
1636 */
1637
1638 char *
1639 bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir)
1640 {
1641   return find_separate_debug_file (abfd, dir, TRUE,
1642                                    get_alt_debug_link_info_shim,
1643                                    separate_alt_debug_file_exists,
1644                                    NULL);
1645 }
1646
1647 /*
1648 FUNCTION
1649         bfd_create_gnu_debuglink_section
1650
1651 SYNOPSIS
1652         struct bfd_section *bfd_create_gnu_debuglink_section
1653           (bfd *abfd, const char *filename);
1654
1655 DESCRIPTION
1656         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The
1657         section is sized to be big enough to contain a link to the specified
1658         @var{filename}.
1659
1660 RETURNS
1661         A pointer to the new section is returned if all is ok.  Otherwise
1662         <<NULL>> is returned and bfd_error is set.
1663 */
1664
1665 asection *
1666 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1667 {
1668   asection *sect;
1669   bfd_size_type debuglink_size;
1670   flagword flags;
1671
1672   if (abfd == NULL || filename == NULL)
1673     {
1674       bfd_set_error (bfd_error_invalid_operation);
1675       return NULL;
1676     }
1677
1678   /* Strip off any path components in filename.  */
1679   filename = lbasename (filename);
1680
1681   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1682   if (sect)
1683     {
1684       /* Section already exists.  */
1685       bfd_set_error (bfd_error_invalid_operation);
1686       return NULL;
1687     }
1688
1689   flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1690   sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1691   if (sect == NULL)
1692     return NULL;
1693
1694   /* Compute the size of the section.  Allow for the CRC after the filename,
1695      and padding so that it will start on a 4-byte boundary.  */
1696   debuglink_size = strlen (filename) + 1;
1697   debuglink_size += 3;
1698   debuglink_size &= ~3;
1699   debuglink_size += 4;
1700
1701   if (! bfd_set_section_size (abfd, sect, debuglink_size))
1702     /* XXX Should we delete the section from the bfd ?  */
1703     return NULL;
1704
1705   /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1706      Note - despite the name of the function being called, we are
1707      setting an alignment power, not a byte alignment value.  */
1708   bfd_set_section_alignment (abfd, sect, 2);
1709
1710   return sect;
1711 }
1712
1713
1714 /*
1715 FUNCTION
1716         bfd_fill_in_gnu_debuglink_section
1717
1718 SYNOPSIS
1719         bfd_boolean bfd_fill_in_gnu_debuglink_section
1720           (bfd *abfd, struct bfd_section *sect, const char *filename);
1721
1722 DESCRIPTION
1723         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1724         and fills in the contents of the section to contain a link to the
1725         specified @var{filename}.  The filename should be relative to the
1726         current directory.
1727
1728 RETURNS
1729         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1730         and bfd_error is set.
1731 */
1732
1733 bfd_boolean
1734 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1735                                    struct bfd_section *sect,
1736                                    const char *filename)
1737 {
1738   bfd_size_type debuglink_size;
1739   unsigned long crc32;
1740   char * contents;
1741   bfd_size_type crc_offset;
1742   FILE * handle;
1743   static unsigned char buffer[8 * 1024];
1744   size_t count;
1745   size_t filelen;
1746
1747   if (abfd == NULL || sect == NULL || filename == NULL)
1748     {
1749       bfd_set_error (bfd_error_invalid_operation);
1750       return FALSE;
1751     }
1752
1753   /* Make sure that we can read the file.
1754      XXX - Should we attempt to locate the debug info file using the same
1755      algorithm as gdb ?  At the moment, since we are creating the
1756      .gnu_debuglink section, we insist upon the user providing us with a
1757      correct-for-section-creation-time path, but this need not conform to
1758      the gdb location algorithm.  */
1759   handle = _bfd_real_fopen (filename, FOPEN_RB);
1760   if (handle == NULL)
1761     {
1762       bfd_set_error (bfd_error_system_call);
1763       return FALSE;
1764     }
1765
1766   crc32 = 0;
1767   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1768     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1769   fclose (handle);
1770
1771   /* Strip off any path components in filename,
1772      now that we no longer need them.  */
1773   filename = lbasename (filename);
1774
1775   filelen = strlen (filename);
1776   debuglink_size = filelen + 1;
1777   debuglink_size += 3;
1778   debuglink_size &= ~3;
1779   debuglink_size += 4;
1780
1781   contents = (char *) bfd_malloc (debuglink_size);
1782   if (contents == NULL)
1783     {
1784       /* XXX Should we delete the section from the bfd ?  */
1785       return FALSE;
1786     }
1787
1788   crc_offset = debuglink_size - 4;
1789   memcpy (contents, filename, filelen);
1790   memset (contents + filelen, 0, crc_offset - filelen);
1791
1792   bfd_put_32 (abfd, crc32, contents + crc_offset);
1793
1794   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1795     {
1796       /* XXX Should we delete the section from the bfd ?  */
1797       free (contents);
1798       return FALSE;
1799     }
1800
1801   return TRUE;
1802 }
1803
1804 /*
1805 INTERNAL_FUNCTION
1806         get_build_id
1807
1808 SYNOPSIS
1809         struct bfd_build_id * get_build_id (bfd *abfd);
1810
1811 DESCRIPTION
1812         Finds the build-id associated with @var{abfd}.  If the build-id is
1813         extracted from the note section then a build-id structure is built
1814         for it, using memory allocated to @var{abfd}, and this is then
1815         attached to the @var{abfd}.
1816
1817 RETURNS
1818         Returns a pointer to the build-id structure if a build-id could be
1819         found.  If no build-id is found NULL is returned and error code is
1820         set.
1821 */
1822
1823 static struct bfd_build_id *
1824 get_build_id (bfd *abfd)
1825 {
1826   struct bfd_build_id *build_id;
1827   Elf_Internal_Note inote;
1828   Elf_External_Note *enote;
1829   bfd_byte *contents;
1830   asection *sect;
1831   bfd_size_type size;
1832
1833   BFD_ASSERT (abfd);
1834
1835   if (abfd->build_id && abfd->build_id->size > 0)
1836     /* Save some time by using the already computed build-id.  */
1837     return (struct bfd_build_id *) abfd->build_id;
1838
1839   sect = bfd_get_section_by_name (abfd, ".note.gnu.build-id");
1840   if (sect == NULL)
1841     {
1842       bfd_set_error (bfd_error_no_debug_section);
1843       return NULL;
1844     }
1845
1846   size = bfd_get_section_size (sect);
1847   /* FIXME: Should we support smaller build-id notes ?  */
1848   if (size < 0x24)
1849     {
1850       bfd_set_error (bfd_error_invalid_operation);
1851       return NULL;
1852     }
1853
1854   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1855     {
1856       if (contents != NULL)
1857         free (contents);
1858       return NULL;
1859     }
1860
1861   /* FIXME: Paranoia - allow for compressed build-id sections.
1862      Maybe we should complain if this size is different from
1863      the one obtained above...  */
1864   size = bfd_get_section_size (sect);
1865   if (size < sizeof (Elf_External_Note))
1866     {
1867       bfd_set_error (bfd_error_invalid_operation);
1868       free (contents);
1869       return NULL;
1870     }
1871
1872   enote = (Elf_External_Note *) contents;
1873   inote.type = H_GET_32 (abfd, enote->type);
1874   inote.namesz = H_GET_32 (abfd, enote->namesz);
1875   inote.namedata = enote->name;
1876   inote.descsz = H_GET_32 (abfd, enote->descsz);
1877   inote.descdata = inote.namedata + BFD_ALIGN (inote.namesz, 4);
1878   /* FIXME: Should we check for extra notes in this section ?  */
1879
1880   if (inote.descsz == 0
1881       || inote.type != NT_GNU_BUILD_ID
1882       || inote.namesz != 4 /* sizeof "GNU"  */
1883       || strncmp (inote.namedata, "GNU", 4) != 0
1884       || size < (12 + BFD_ALIGN (inote.namesz, 4) + inote.descsz))
1885     {
1886       free (contents);
1887       bfd_set_error (bfd_error_invalid_operation);
1888       return NULL;
1889     }
1890
1891   build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) + inote.descsz);
1892   if (build_id == NULL)
1893     {
1894       free (contents);
1895       return NULL;
1896     }
1897
1898   build_id->size = inote.descsz;
1899   memcpy (build_id->data, inote.descdata, inote.descsz);
1900   abfd->build_id = build_id;
1901   free (contents);
1902
1903   return build_id;
1904 }
1905
1906 /*
1907 INTERNAL_FUNCTION
1908         get_build_id_name
1909
1910 SYNOPSIS
1911         char * get_build_id_name (bfd *abfd, void *build_id_out_p)
1912
1913 DESCRIPTION
1914         Searches @var{abfd} for a build-id, and then constructs a pathname
1915         from it.  The path is computed as .build-id/NN/NN+NN.debug where
1916         NNNN+NN is the build-id value as a hexadecimal string.
1917
1918 RETURNS
1919         Returns the constructed filename or NULL upon error.
1920         It is the caller's responsibility to free the memory used to hold the
1921         filename.
1922         If a filename is returned then the @var{build_id_out_p}
1923         parameter (which points to a @code{struct bfd_build_id}
1924         pointer) is set to a pointer to the build_id structure.
1925 */
1926
1927 static char *
1928 get_build_id_name (bfd *abfd, void *build_id_out_p)
1929 {
1930   struct bfd_build_id **build_id_out = build_id_out_p;
1931   struct bfd_build_id *build_id;
1932   char *name;
1933   char *n;
1934   bfd_size_type s;
1935   bfd_byte *d;
1936
1937   if (abfd == NULL || abfd->filename == NULL || build_id_out == NULL)
1938     {
1939       bfd_set_error (bfd_error_invalid_operation);
1940       return NULL;
1941     }
1942
1943   build_id = get_build_id (abfd);
1944   if (build_id == NULL)
1945     return NULL;
1946
1947   /* Compute the debug pathname corresponding to the build-id.  */
1948   name = bfd_malloc (strlen (".build-id/") + build_id->size * 2 + 2 + strlen (".debug"));
1949   if (name == NULL)
1950     {
1951       bfd_set_error (bfd_error_no_memory);
1952       return NULL;
1953     }
1954   n = name;
1955   d = build_id->data;
1956   s = build_id->size;
1957
1958   n += sprintf (n, ".build-id/");
1959   n += sprintf (n, "%02x", (unsigned) *d++); s--;
1960   n += sprintf (n, "/");
1961   while (s--)
1962     n += sprintf (n, "%02x", (unsigned) *d++);
1963   n += sprintf (n, ".debug");
1964
1965   *build_id_out = build_id;
1966   return name;
1967 }
1968
1969 /*
1970 INTERNAL_FUNCTION
1971         check_build_id_file
1972
1973 SYNOPSIS
1974         bfd_boolean check_build_id_file (char *name, void *buildid_p);
1975
1976 DESCRIPTION
1977         Checks to see if @var{name} is a readable file and if its build-id
1978         matches @var{buildid}.
1979
1980 RETURNS
1981         Returns TRUE if the file exists, is readable, and contains a
1982         build-id which matches the build-id pointed at by
1983         @var{build_id_p} (which is really a @code{struct bfd_build_id **}).
1984 */
1985
1986 static bfd_boolean
1987 check_build_id_file (const char *name, void *buildid_p)
1988 {
1989   struct bfd_build_id *orig_build_id;
1990   struct bfd_build_id *build_id;
1991   bfd * file;
1992   bfd_boolean result;
1993
1994   BFD_ASSERT (name);
1995   BFD_ASSERT (buildid_p);
1996
1997   file = bfd_openr (name, NULL);
1998   if (file == NULL)
1999     return FALSE;
2000
2001   /* If the file is an archive, process all of its elements.  */
2002   if (! bfd_check_format (file, bfd_object))
2003     {
2004       bfd_close (file);
2005       return FALSE;
2006     }
2007
2008   build_id = get_build_id (file);
2009   if (build_id == NULL)
2010     {
2011       bfd_close (file);
2012       return FALSE;
2013     }
2014
2015   orig_build_id = *(struct bfd_build_id **) buildid_p;
2016
2017   result = build_id->size == orig_build_id->size
2018     && memcmp (build_id->data, orig_build_id->data, build_id->size) == 0;
2019
2020   (void) bfd_close (file);
2021
2022   return result;
2023 }
2024
2025 /*
2026 FUNCTION
2027         bfd_follow_build_id_debuglink
2028
2029 SYNOPSIS
2030         char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
2031
2032 DESCRIPTION
2033         Takes @var{abfd} and searches it for a .note.gnu.build-id section.
2034         If this section is found, it extracts the value of the NT_GNU_BUILD_ID
2035         note, which should be a hexadecimal value @var{NNNN+NN} (for
2036         32+ hex digits).  It then searches the filesystem for a file named
2037         @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
2038         including the directory tree rooted at @var{dir}.  The filename
2039         of the first matching file to be found is returned.  A matching
2040         file should contain a .note.gnu.build-id section with the same
2041         @var{NNNN+NN} note as @var{abfd}, although this check is currently
2042         not implemented.
2043
2044         If @var{dir} is NULL, the search will take place starting at
2045         the current directory.
2046
2047 RETURNS
2048         <<NULL>> on any errors or failure to locate the debug file,
2049         otherwise a pointer to a heap-allocated string containing the
2050         filename.  The caller is responsible for freeing this string.
2051 */
2052
2053 char *
2054 bfd_follow_build_id_debuglink (bfd *abfd, const char *dir)
2055 {
2056   struct bfd_build_id *build_id;
2057
2058   return find_separate_debug_file (abfd, dir, FALSE,
2059                                    get_build_id_name,
2060                                    check_build_id_file, &build_id);
2061 }