bfd/opncls.c

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