bfd/opncls.c

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