bfd/opncls.c

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