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