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   unsigned long ul_size = (unsigned long) size;
 941
 942   if (size != ul_size
 943       /* A small negative size can result in objalloc_alloc allocating just
 944          1 byte of memory, but the caller will be expecting more.  So catch
 945          this case here.  */
 946       || (size != 0 && (((ul_size + OBJALLOC_ALIGN - 1) &~ (OBJALLOC_ALIGN - 1)) == 0)))
 947     {
 948       bfd_set_error (bfd_error_no_memory);
 949       return NULL;
 950     }
 951
 952   ret = objalloc_alloc ((struct objalloc *) abfd->memory, ul_size);
 953   if (ret == NULL)
 954     bfd_set_error (bfd_error_no_memory);
 955   return ret;
 956 }
 957
 958 /*
 959 INTERNAL_FUNCTION
 960         bfd_alloc2
 961
 962 SYNOPSIS
 963         void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
 964
 965 DESCRIPTION
 966         Allocate a block of @var{nmemb} elements of @var{size} bytes each
 967         of memory attached to <<abfd>> and return a pointer to it.
 968 */
 969
 970 void *
 971 bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
 972 {
 973   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
 974       && size != 0
 975       && nmemb > ~(bfd_size_type) 0 / size)
 976     {
 977       bfd_set_error (bfd_error_no_memory);
 978       return NULL;
 979     }
 980
 981   return bfd_alloc (abfd, size * nmemb);
 982 }
 983
 984 /*
 985 FUNCTION
 986         bfd_zalloc
 987
 988 SYNOPSIS
 989         void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
 990
 991 DESCRIPTION
 992         Allocate a block of @var{wanted} bytes of zeroed memory
 993         attached to <<abfd>> and return a pointer to it.
 994 */
 995
 996 void *
 997 bfd_zalloc (bfd *abfd, bfd_size_type size)
 998 {
 999   void *res;
1000
1001   res = bfd_alloc (abfd, size);
1002   if (res)
1003     memset (res, 0, (size_t) size);
1004   return res;
1005 }
1006
1007 /*
1008 INTERNAL_FUNCTION
1009         bfd_zalloc2
1010
1011 SYNOPSIS
1012         void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
1013
1014 DESCRIPTION
1015         Allocate a block of @var{nmemb} elements of @var{size} bytes each
1016         of zeroed memory attached to <<abfd>> and return a pointer to it.
1017 */
1018
1019 void *
1020 bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
1021 {
1022   void *res;
1023
1024   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
1025       && size != 0
1026       && nmemb > ~(bfd_size_type) 0 / size)
1027     {
1028       bfd_set_error (bfd_error_no_memory);
1029       return NULL;
1030     }
1031
1032   size *= nmemb;
1033
1034   res = bfd_alloc (abfd, size);
1035   if (res)
1036     memset (res, 0, (size_t) size);
1037   return res;
1038 }
1039
1040 /* Free a block allocated for a BFD.
1041    Note:  Also frees all more recently allocated blocks!  */
1042
1043 void
1044 bfd_release (bfd *abfd, void *block)
1045 {
1046   objalloc_free_block ((struct objalloc *) abfd->memory, block);
1047 }
1048
1049
1050 /*
1051    GNU Extension: separate debug-info files
1052
1053    The idea here is that a special section called .gnu_debuglink might be
1054    embedded in a binary file, which indicates that some *other* file
1055    contains the real debugging information. This special section contains a
1056    filename and CRC32 checksum, which we read and resolve to another file,
1057    if it exists.
1058
1059    This facilitates "optional" provision of debugging information, without
1060    having to provide two complete copies of every binary object (with and
1061    without debug symbols).  */
1062
1063 #define GNU_DEBUGLINK           ".gnu_debuglink"
1064 #define GNU_DEBUGALTLINK        ".gnu_debugaltlink"
1065
1066 /*
1067 FUNCTION
1068         bfd_calc_gnu_debuglink_crc32
1069
1070 SYNOPSIS
1071         unsigned long bfd_calc_gnu_debuglink_crc32
1072           (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1073
1074 DESCRIPTION
1075         Computes a CRC value as used in the .gnu_debuglink section.
1076         Advances the previously computed @var{crc} value by computing
1077         and adding in the crc32 for @var{len} bytes of @var{buf}.
1078
1079 RETURNS
1080         Return the updated CRC32 value.
1081 */
1082
1083 unsigned long
1084 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1085                               const unsigned char *buf,
1086                               bfd_size_type len)
1087 {
1088   static const unsigned long crc32_table[256] =
1089     {
1090       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1091       0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1092       0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1093       0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1094       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1095       0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1096       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1097       0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1098       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1099       0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1100       0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1101       0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1102       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1103       0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1104       0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1105       0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1106       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1107       0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1108       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1109       0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1110       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1111       0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1112       0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1113       0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1114       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1115       0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1116       0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1117       0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1118       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1119       0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1120       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1121       0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1122       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1123       0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1124       0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1125       0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1126       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1127       0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1128       0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1129       0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1130       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1131       0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1132       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1133       0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1134       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1135       0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1136       0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1137       0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1138       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1139       0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1140       0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1141       0x2d02ef8d
1142     };
1143   const unsigned char *end;
1144
1145   crc = ~crc & 0xffffffff;
1146   for (end = buf + len; buf < end; ++ buf)
1147     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1148   return ~crc & 0xffffffff;
1149 }
1150
1151
1152 /*
1153 FUNCTION
1154         bfd_get_debug_link_info
1155
1156 SYNOPSIS
1157         char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1158
1159 DESCRIPTION
1160         Fetch the filename and CRC32 value for any separate debuginfo
1161         associated with @var{abfd}.  Return NULL if no such info found,
1162         otherwise return filename and update @var{crc32_out}.  The
1163         returned filename is allocated with @code{malloc}; freeing it
1164         is the responsibility of the caller.
1165 */
1166
1167 char *
1168 bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1169 {
1170   asection *sect;
1171   unsigned long crc32;
1172   bfd_byte *contents;
1173   int crc_offset;
1174   char *name;
1175
1176   BFD_ASSERT (abfd);
1177   BFD_ASSERT (crc32_out);
1178
1179   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1180
1181   if (sect == NULL)
1182     return NULL;
1183
1184   if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1185     {
1186       if (contents != NULL)
1187         free (contents);
1188       return NULL;
1189     }
1190
1191   /* Crc value is stored after the filename, aligned up to 4 bytes.  */
1192   name = (char *) contents;
1193   crc_offset = strlen (name) + 1;
1194   crc_offset = (crc_offset + 3) & ~3;
1195
1196   crc32 = bfd_get_32 (abfd, contents + crc_offset);
1197
1198   *crc32_out = crc32;
1199   return name;
1200 }
1201
1202 /*
1203 FUNCTION
1204         bfd_get_alt_debug_link_info
1205
1206 SYNOPSIS
1207         char *bfd_get_alt_debug_link_info (bfd * abfd,
1208                                            bfd_size_type *buildid_len,
1209                                            bfd_byte **buildid_out);
1210
1211 DESCRIPTION
1212         Fetch the filename and BuildID value for any alternate debuginfo
1213         associated with @var{abfd}.  Return NULL if no such info found,
1214         otherwise return filename and update @var{buildid_len} and
1215         @var{buildid_out}.  The returned filename and build_id are
1216         allocated with @code{malloc}; freeing them is the
1217         responsibility of the caller.
1218 */
1219
1220 char *
1221 bfd_get_alt_debug_link_info (bfd * abfd, bfd_size_type *buildid_len,
1222                              bfd_byte **buildid_out)
1223 {
1224   asection *sect;
1225   bfd_byte *contents;
1226   int buildid_offset;
1227   char *name;
1228
1229   BFD_ASSERT (abfd);
1230   BFD_ASSERT (buildid_len);
1231   BFD_ASSERT (buildid_out);
1232
1233   sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK);
1234
1235   if (sect == NULL)
1236     return NULL;
1237
1238   if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1239     {
1240       if (contents != NULL)
1241         free (contents);
1242       return NULL;
1243     }
1244
1245   /* BuildID value is stored after the filename.  */
1246   name = (char *) contents;
1247   buildid_offset = strlen (name) + 1;
1248
1249   *buildid_len = bfd_get_section_size (sect) - buildid_offset;
1250   *buildid_out = bfd_malloc (*buildid_len);
1251   memcpy (*buildid_out, contents + buildid_offset, *buildid_len);
1252
1253   return name;
1254 }
1255
1256 /*
1257 INTERNAL_FUNCTION
1258         separate_debug_file_exists
1259
1260 SYNOPSIS
1261         bfd_boolean separate_debug_file_exists
1262           (char *name, unsigned long crc32);
1263
1264 DESCRIPTION
1265         Checks to see if @var{name} is a file and if its contents
1266         match @var{crc32}.
1267 */
1268
1269 static bfd_boolean
1270 separate_debug_file_exists (const char *name, const unsigned long crc)
1271 {
1272   static unsigned char buffer [8 * 1024];
1273   unsigned long file_crc = 0;
1274   FILE *f;
1275   bfd_size_type count;
1276
1277   BFD_ASSERT (name);
1278
1279   f = real_fopen (name, FOPEN_RB);
1280   if (f == NULL)
1281     return FALSE;
1282
1283   while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1284     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1285
1286   fclose (f);
1287
1288   return crc == file_crc;
1289 }
1290
1291 /*
1292 INTERNAL_FUNCTION
1293         separate_alt_debug_file_exists
1294
1295 SYNOPSIS
1296         bfd_boolean separate_alt_debug_file_exists
1297           (char *name, unsigned long crc32);
1298
1299 DESCRIPTION
1300         Checks to see if @var{name} is a file and if its BuildID
1301         matches @var{buildid}.
1302 */
1303
1304 static bfd_boolean
1305 separate_alt_debug_file_exists (const char *name,
1306                                 const unsigned long buildid ATTRIBUTE_UNUSED)
1307 {
1308   FILE *f;
1309
1310   BFD_ASSERT (name);
1311
1312   f = real_fopen (name, FOPEN_RB);
1313   if (f == NULL)
1314     return FALSE;
1315
1316   /* FIXME: Add code to check buildid.  */
1317
1318   fclose (f);
1319
1320   return TRUE;
1321 }
1322
1323 /*
1324 INTERNAL_FUNCTION
1325         find_separate_debug_file
1326
1327 SYNOPSIS
1328         char *find_separate_debug_file (bfd *abfd);
1329
1330 DESCRIPTION
1331         Searches @var{abfd} for a section called @var{section_name} which
1332         is expected to contain a reference to a file containing separate
1333         debugging information.  The function scans various locations in
1334         the filesystem, including the file tree rooted at
1335         @var{debug_file_directory}, and returns the first matching
1336         filename that it finds.  If @var{check_crc} is TRUE then the
1337         contents of the file must also match the CRC value contained in
1338         @var{section_name}.  Returns NULL if no valid file could be found.
1339 */
1340
1341 typedef char *      (* get_func_type) (bfd *, unsigned long *);
1342 typedef bfd_boolean (* check_func_type) (const char *, const unsigned long);
1343
1344 static char *
1345 find_separate_debug_file (bfd *           abfd,
1346                           const char *    debug_file_directory,
1347                           get_func_type   get_func,
1348                           check_func_type check_func)
1349 {
1350   char *base;
1351   char *dir;
1352   char *debugfile;
1353   char *canon_dir;
1354   unsigned long crc32;
1355   size_t dirlen;
1356   size_t canon_dirlen;
1357
1358   BFD_ASSERT (abfd);
1359   if (debug_file_directory == NULL)
1360     debug_file_directory = ".";
1361
1362   /* BFD may have been opened from a stream.  */
1363   if (abfd->filename == NULL)
1364     {
1365       bfd_set_error (bfd_error_invalid_operation);
1366       return NULL;
1367     }
1368
1369   base = get_func (abfd, & crc32);
1370
1371   if (base == NULL)
1372     return NULL;
1373
1374   if (base[0] == '\0')
1375     {
1376       free (base);
1377       bfd_set_error (bfd_error_no_debug_section);
1378       return NULL;
1379     }
1380
1381   for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--)
1382     if (IS_DIR_SEPARATOR (abfd->filename[dirlen - 1]))
1383       break;
1384
1385   dir = (char *) bfd_malloc (dirlen + 1);
1386   if (dir == NULL)
1387     {
1388       free (base);
1389       return NULL;
1390     }
1391   memcpy (dir, abfd->filename, dirlen);
1392   dir[dirlen] = '\0';
1393
1394   /* Compute the canonical name of the bfd object with all symbolic links
1395      resolved, for use in the global debugfile directory.  */
1396   canon_dir = lrealpath (abfd->filename);
1397   for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1398     if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1399       break;
1400   canon_dir[canon_dirlen] = '\0';
1401
1402   debugfile = (char *)
1403       bfd_malloc (strlen (debug_file_directory) + 1
1404                   + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1405                   + strlen (".debug/")
1406                   + strlen (base)
1407                   + 1);
1408   if (debugfile == NULL)
1409     goto found; /* Actually this returns NULL.  */
1410
1411   /* First try in the same directory as the original file:  */
1412   strcpy (debugfile, dir);
1413   strcat (debugfile, base);
1414
1415   if (check_func (debugfile, crc32))
1416     goto found;
1417
1418   /* Then try in a subdirectory called .debug.  */
1419   strcpy (debugfile, dir);
1420   strcat (debugfile, ".debug/");
1421   strcat (debugfile, base);
1422
1423   if (check_func (debugfile, crc32))
1424     goto found;
1425
1426   /* Then try in the global debugfile directory.  */
1427   strcpy (debugfile, debug_file_directory);
1428   dirlen = strlen (debug_file_directory) - 1;
1429   if (dirlen > 0
1430       && debug_file_directory[dirlen] != '/'
1431       && canon_dir[0] != '/')
1432     strcat (debugfile, "/");
1433   strcat (debugfile, canon_dir);
1434   strcat (debugfile, base);
1435
1436   if (check_func (debugfile, crc32))
1437     goto found;
1438
1439   /* Failed to find the file.  */
1440   free (debugfile);
1441   debugfile = NULL;
1442
1443  found:
1444   free (base);
1445   free (dir);
1446   free (canon_dir);
1447   return debugfile;
1448 }
1449
1450
1451 /*
1452 FUNCTION
1453         bfd_follow_gnu_debuglink
1454
1455 SYNOPSIS
1456         char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1457
1458 DESCRIPTION
1459
1460         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1461         section is found, it examines the section for the name and checksum
1462         of a '.debug' file containing auxiliary debugging information.  It
1463         then searches the filesystem for this .debug file in some standard
1464         locations, including the directory tree rooted at @var{dir}, and if
1465         found returns the full filename.
1466
1467         If @var{dir} is NULL, it will search a default path configured into
1468         libbfd at build time.  [XXX this feature is not currently
1469         implemented].
1470
1471 RETURNS
1472         <<NULL>> on any errors or failure to locate the .debug file,
1473         otherwise a pointer to a heap-allocated string containing the
1474         filename.  The caller is responsible for freeing this string.
1475 */
1476
1477 char *
1478 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1479 {
1480   return find_separate_debug_file (abfd, dir,
1481                                    bfd_get_debug_link_info,
1482                                    separate_debug_file_exists);
1483 }
1484
1485 /* Helper for bfd_follow_gnu_debugaltlink.  It just pretends to return
1486    a CRC.  .gnu_debugaltlink supplies a build-id, which is different,
1487    but this is ok because separate_alt_debug_file_exists ignores the
1488    CRC anyway.  */
1489
1490 static char *
1491 get_alt_debug_link_info_shim (bfd * abfd, unsigned long *crc32_out)
1492 {
1493   bfd_size_type len;
1494   bfd_byte *buildid = NULL;
1495   char *result = bfd_get_alt_debug_link_info (abfd, &len, &buildid);
1496
1497   *crc32_out = 0;
1498   free (buildid);
1499
1500   return result;
1501 }
1502
1503 /*
1504 FUNCTION
1505         bfd_follow_gnu_debugaltlink
1506
1507 SYNOPSIS
1508         char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1509
1510 DESCRIPTION
1511
1512         Takes a BFD and searches it for a .gnu_debugaltlink section.  If this
1513         section is found, it examines the section for the name of a file
1514         containing auxiliary debugging information.  It then searches the
1515         filesystem for this file in a set of standard locations, including
1516         the directory tree rooted at @var{dir}, and if found returns the
1517         full filename.
1518
1519         If @var{dir} is NULL, it will search a default path configured into
1520         libbfd at build time.  [FIXME: This feature is not currently
1521         implemented].
1522
1523 RETURNS
1524         <<NULL>> on any errors or failure to locate the debug file,
1525         otherwise a pointer to a heap-allocated string containing the
1526         filename.  The caller is responsible for freeing this string.
1527 */
1528
1529 char *
1530 bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir)
1531 {
1532   return find_separate_debug_file (abfd, dir,
1533                                    get_alt_debug_link_info_shim,
1534                                    separate_alt_debug_file_exists);
1535 }
1536
1537 /*
1538 FUNCTION
1539         bfd_create_gnu_debuglink_section
1540
1541 SYNOPSIS
1542         struct bfd_section *bfd_create_gnu_debuglink_section
1543           (bfd *abfd, const char *filename);
1544
1545 DESCRIPTION
1546
1547         Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The section is sized
1548         to be big enough to contain a link to the specified @var{filename}.
1549
1550 RETURNS
1551         A pointer to the new section is returned if all is ok.  Otherwise <<NULL>> is
1552         returned and bfd_error is set.
1553 */
1554
1555 asection *
1556 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1557 {
1558   asection *sect;
1559   bfd_size_type debuglink_size;
1560   flagword flags;
1561
1562   if (abfd == NULL || filename == NULL)
1563     {
1564       bfd_set_error (bfd_error_invalid_operation);
1565       return NULL;
1566     }
1567
1568   /* Strip off any path components in filename.  */
1569   filename = lbasename (filename);
1570
1571   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1572   if (sect)
1573     {
1574       /* Section already exists.  */
1575       bfd_set_error (bfd_error_invalid_operation);
1576       return NULL;
1577     }
1578
1579   flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1580   sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1581   if (sect == NULL)
1582     return NULL;
1583
1584   debuglink_size = strlen (filename) + 1;
1585   debuglink_size += 3;
1586   debuglink_size &= ~3;
1587   debuglink_size += 4;
1588
1589   if (! bfd_set_section_size (abfd, sect, debuglink_size))
1590     /* XXX Should we delete the section from the bfd ?  */
1591     return NULL;
1592
1593   return sect;
1594 }
1595
1596
1597 /*
1598 FUNCTION
1599         bfd_fill_in_gnu_debuglink_section
1600
1601 SYNOPSIS
1602         bfd_boolean bfd_fill_in_gnu_debuglink_section
1603           (bfd *abfd, struct bfd_section *sect, const char *filename);
1604
1605 DESCRIPTION
1606
1607         Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1608         and fills in the contents of the section to contain a link to the
1609         specified @var{filename}.  The filename should be relative to the
1610         current directory.
1611
1612 RETURNS
1613         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1614         and bfd_error is set.
1615 */
1616
1617 bfd_boolean
1618 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1619                                    struct bfd_section *sect,
1620                                    const char *filename)
1621 {
1622   bfd_size_type debuglink_size;
1623   unsigned long crc32;
1624   char * contents;
1625   bfd_size_type crc_offset;
1626   FILE * handle;
1627   static unsigned char buffer[8 * 1024];
1628   size_t count;
1629   size_t filelen;
1630
1631   if (abfd == NULL || sect == NULL || filename == NULL)
1632     {
1633       bfd_set_error (bfd_error_invalid_operation);
1634       return FALSE;
1635     }
1636
1637   /* Make sure that we can read the file.
1638      XXX - Should we attempt to locate the debug info file using the same
1639      algorithm as gdb ?  At the moment, since we are creating the
1640      .gnu_debuglink section, we insist upon the user providing us with a
1641      correct-for-section-creation-time path, but this need not conform to
1642      the gdb location algorithm.  */
1643   handle = real_fopen (filename, FOPEN_RB);
1644   if (handle == NULL)
1645     {
1646       bfd_set_error (bfd_error_system_call);
1647       return FALSE;
1648     }
1649
1650   crc32 = 0;
1651   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1652     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1653   fclose (handle);
1654
1655   /* Strip off any path components in filename,
1656      now that we no longer need them.  */
1657   filename = lbasename (filename);
1658
1659   filelen = strlen (filename);
1660   debuglink_size = filelen + 1;
1661   debuglink_size += 3;
1662   debuglink_size &= ~3;
1663   debuglink_size += 4;
1664
1665   contents = (char *) bfd_malloc (debuglink_size);
1666   if (contents == NULL)
1667     {
1668       /* XXX Should we delete the section from the bfd ?  */
1669       return FALSE;
1670     }
1671
1672   crc_offset = debuglink_size - 4;
1673   memcpy (contents, filename, filelen);
1674   memset (contents + filelen, 0, crc_offset - filelen);
1675
1676   bfd_put_32 (abfd, crc32, contents + crc_offset);
1677
1678   if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1679     {
1680       /* XXX Should we delete the section from the bfd ?  */
1681       free (contents);
1682       return FALSE;
1683     }
1684
1685   return TRUE;
1686 }