contrib/binutils-2.27/bfd/opncls.c

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