bfd/opncls.c

   1 /* opncls.c -- open and close a BFD.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
   3    2001, 2002, 2003
   4    Free Software Foundation, Inc.
   5
   6    Written by Cygnus Support.
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  23
  24 #include "bfd.h"
  25 #include "sysdep.h"
  26 #include "objalloc.h"
  27 #include "libbfd.h"
  28 #include "libiberty.h"
  29
  30 #ifndef S_IXUSR
  31 #define S_IXUSR 0100    /* Execute by owner.  */
  32 #endif
  33 #ifndef S_IXGRP
  34 #define S_IXGRP 0010    /* Execute by group.  */
  35 #endif
  36 #ifndef S_IXOTH
  37 #define S_IXOTH 0001    /* Execute by others.  */
  38 #endif
  39
  40 /* Counter used to initialize the bfd identifier.  */
  41
  42 static unsigned int _bfd_id_counter = 0;
  43
  44 /* fdopen is a loser -- we should use stdio exclusively.  Unfortunately
  45    if we do that we can't use fcntl.  */
  46
  47 /* Return a new BFD.  All BFD's are allocated through this routine.  */
  48
  49 bfd *
  50 _bfd_new_bfd ()
  51 {
  52   bfd *nbfd;
  53
  54   nbfd = (bfd *) bfd_zmalloc ((bfd_size_type) sizeof (bfd));
  55   if (nbfd == NULL)
  56     return NULL;
  57
  58   nbfd->id = _bfd_id_counter++;
  59
  60   nbfd->memory = (PTR) objalloc_create ();
  61   if (nbfd->memory == NULL)
  62     {
  63       bfd_set_error (bfd_error_no_memory);
  64       free (nbfd);
  65       return NULL;
  66     }
  67
  68   nbfd->arch_info = &bfd_default_arch_struct;
  69
  70   nbfd->direction = no_direction;
  71   nbfd->iostream = NULL;
  72   nbfd->where = 0;
  73   if (!bfd_hash_table_init_n (&nbfd->section_htab,
  74                               bfd_section_hash_newfunc,
  75                               251))
  76     {
  77       free (nbfd);
  78       return NULL;
  79     }
  80   nbfd->sections = (asection *) NULL;
  81   nbfd->section_tail = &nbfd->sections;
  82   nbfd->format = bfd_unknown;
  83   nbfd->my_archive = (bfd *) NULL;
  84   nbfd->origin = 0;
  85   nbfd->opened_once = FALSE;
  86   nbfd->output_has_begun = FALSE;
  87   nbfd->section_count = 0;
  88   nbfd->usrdata = (PTR) NULL;
  89   nbfd->cacheable = FALSE;
  90   nbfd->flags = BFD_NO_FLAGS;
  91   nbfd->mtime_set = FALSE;
  92
  93   return nbfd;
  94 }
  95
  96 /* Allocate a new BFD as a member of archive OBFD.  */
  97
  98 bfd *
  99 _bfd_new_bfd_contained_in (obfd)
 100      bfd *obfd;
 101 {
 102   bfd *nbfd;
 103
 104   nbfd = _bfd_new_bfd ();
 105   if (nbfd == NULL)
 106     return NULL;
 107   nbfd->xvec = obfd->xvec;
 108   nbfd->my_archive = obfd;
 109   nbfd->direction = read_direction;
 110   nbfd->target_defaulted = obfd->target_defaulted;
 111   return nbfd;
 112 }
 113
 114 /* Delete a BFD.  */
 115
 116 void
 117 _bfd_delete_bfd (abfd)
 118      bfd *abfd;
 119 {
 120   bfd_hash_table_free (&abfd->section_htab);
 121   objalloc_free ((struct objalloc *) abfd->memory);
 122   free (abfd);
 123 }
 124
 125 /*
 126 SECTION
 127         Opening and closing BFDs
 128
 129 */
 130
 131 /*
 132 FUNCTION
 133         bfd_openr
 134
 135 SYNOPSIS
 136         bfd *bfd_openr(const char *filename, const char *target);
 137
 138 DESCRIPTION
 139         Open the file @var{filename} (using <<fopen>>) with the target
 140         @var{target}.  Return a pointer to the created BFD.
 141
 142         Calls <<bfd_find_target>>, so @var{target} is interpreted as by
 143         that function.
 144
 145         If <<NULL>> is returned then an error has occured.   Possible errors
 146         are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
 147         <<system_call>> error.
 148 */
 149
 150 bfd *
 151 bfd_openr (filename, target)
 152      const char *filename;
 153      const char *target;
 154 {
 155   bfd *nbfd;
 156   const bfd_target *target_vec;
 157
 158   nbfd = _bfd_new_bfd ();
 159   if (nbfd == NULL)
 160     return NULL;
 161
 162   target_vec = bfd_find_target (target, nbfd);
 163   if (target_vec == NULL)
 164     {
 165       _bfd_delete_bfd (nbfd);
 166       return NULL;
 167     }
 168
 169   nbfd->filename = filename;
 170   nbfd->direction = read_direction;
 171
 172   if (bfd_open_file (nbfd) == NULL)
 173     {
 174       /* File didn't exist, or some such.  */
 175       bfd_set_error (bfd_error_system_call);
 176       _bfd_delete_bfd (nbfd);
 177       return NULL;
 178     }
 179
 180   return nbfd;
 181 }
 182
 183 /* Don't try to `optimize' this function:
 184
 185    o - We lock using stack space so that interrupting the locking
 186        won't cause a storage leak.
 187    o - We open the file stream last, since we don't want to have to
 188        close it if anything goes wrong.  Closing the stream means closing
 189        the file descriptor too, even though we didn't open it.  */
 190 /*
 191 FUNCTION
 192         bfd_fdopenr
 193
 194 SYNOPSIS
 195         bfd *bfd_fdopenr(const char *filename, const char *target, int fd);
 196
 197 DESCRIPTION
 198         <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
 199         <<fopen>>.  It opens a BFD on a file already described by the
 200         @var{fd} supplied.
 201
 202         When the file is later <<bfd_close>>d, the file descriptor will
 203         be closed.  If the caller desires that this file descriptor be
 204         cached by BFD (opened as needed, closed as needed to free
 205         descriptors for other opens), with the supplied @var{fd} used as
 206         an initial file descriptor (but subject to closure at any time),
 207         call bfd_set_cacheable(bfd, 1) on the returned BFD.  The default
 208         is to assume no cacheing; the file descriptor will remain open
 209         until <<bfd_close>>, and will not be affected by BFD operations
 210         on other files.
 211
 212         Possible errors are <<bfd_error_no_memory>>,
 213         <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
 214 */
 215
 216 bfd *
 217 bfd_fdopenr (filename, target, fd)
 218      const char *filename;
 219      const char *target;
 220      int fd;
 221 {
 222   bfd *nbfd;
 223   const bfd_target *target_vec;
 224   int fdflags;
 225
 226   bfd_set_error (bfd_error_system_call);
 227 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
 228   fdflags = O_RDWR;                     /* Assume full access.  */
 229 #else
 230   fdflags = fcntl (fd, F_GETFL, NULL);
 231 #endif
 232   if (fdflags == -1)
 233     return NULL;
 234
 235   nbfd = _bfd_new_bfd ();
 236   if (nbfd == NULL)
 237     return NULL;
 238
 239   target_vec = bfd_find_target (target, nbfd);
 240   if (target_vec == NULL)
 241     {
 242       _bfd_delete_bfd (nbfd);
 243       return NULL;
 244     }
 245
 246 #ifndef HAVE_FDOPEN
 247   nbfd->iostream = (PTR) fopen (filename, FOPEN_RB);
 248 #else
 249   /* (O_ACCMODE) parens are to avoid Ultrix header file bug.  */
 250   switch (fdflags & (O_ACCMODE))
 251     {
 252     case O_RDONLY: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RB);   break;
 253     case O_WRONLY: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RUB);  break;
 254     case O_RDWR:   nbfd->iostream = (PTR) fdopen (fd, FOPEN_RUB);  break;
 255     default: abort ();
 256     }
 257 #endif
 258
 259   if (nbfd->iostream == NULL)
 260     {
 261       _bfd_delete_bfd (nbfd);
 262       return NULL;
 263     }
 264
 265   /* OK, put everything where it belongs.  */
 266   nbfd->filename = filename;
 267
 268   /* As a special case we allow a FD open for read/write to
 269      be written through, although doing so requires that we end
 270      the previous clause with a preposition.  */
 271   /* (O_ACCMODE) parens are to avoid Ultrix header file bug.  */
 272   switch (fdflags & (O_ACCMODE))
 273     {
 274     case O_RDONLY: nbfd->direction = read_direction; break;
 275     case O_WRONLY: nbfd->direction = write_direction; break;
 276     case O_RDWR: nbfd->direction = both_direction; break;
 277     default: abort ();
 278     }
 279
 280   if (! bfd_cache_init (nbfd))
 281     {
 282       _bfd_delete_bfd (nbfd);
 283       return NULL;
 284     }
 285   nbfd->opened_once = TRUE;
 286
 287   return nbfd;
 288 }
 289
 290 /*
 291 FUNCTION
 292         bfd_openstreamr
 293
 294 SYNOPSIS
 295         bfd *bfd_openstreamr(const char *, const char *, PTR);
 296
 297 DESCRIPTION
 298
 299         Open a BFD for read access on an existing stdio stream.  When
 300         the BFD is passed to <<bfd_close>>, the stream will be closed.
 301 */
 302
 303 bfd *
 304 bfd_openstreamr (filename, target, streamarg)
 305      const char *filename;
 306      const char *target;
 307      PTR streamarg;
 308 {
 309   FILE *stream = (FILE *) streamarg;
 310   bfd *nbfd;
 311   const bfd_target *target_vec;
 312
 313   nbfd = _bfd_new_bfd ();
 314   if (nbfd == NULL)
 315     return NULL;
 316
 317   target_vec = bfd_find_target (target, nbfd);
 318   if (target_vec == NULL)
 319     {
 320       _bfd_delete_bfd (nbfd);
 321       return NULL;
 322     }
 323
 324   nbfd->iostream = (PTR) stream;
 325   nbfd->filename = filename;
 326   nbfd->direction = read_direction;
 327
 328   if (! bfd_cache_init (nbfd))
 329     {
 330       _bfd_delete_bfd (nbfd);
 331       return NULL;
 332     }
 333
 334   return nbfd;
 335 }
 336 \f
 337 /* bfd_openw -- open for writing.
 338    Returns a pointer to a freshly-allocated BFD on success, or NULL.
 339
 340    See comment by bfd_fdopenr before you try to modify this function.  */
 341
 342 /*
 343 FUNCTION
 344         bfd_openw
 345
 346 SYNOPSIS
 347         bfd *bfd_openw(const char *filename, const char *target);
 348
 349 DESCRIPTION
 350         Create a BFD, associated with file @var{filename}, using the
 351         file format @var{target}, and return a pointer to it.
 352
 353         Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
 354         <<bfd_error_invalid_target>>.
 355 */
 356
 357 bfd *
 358 bfd_openw (filename, target)
 359      const char *filename;
 360      const char *target;
 361 {
 362   bfd *nbfd;
 363   const bfd_target *target_vec;
 364
 365   /* nbfd has to point to head of malloc'ed block so that bfd_close may
 366      reclaim it correctly.  */
 367   nbfd = _bfd_new_bfd ();
 368   if (nbfd == NULL)
 369     return NULL;
 370
 371   target_vec = bfd_find_target (target, nbfd);
 372   if (target_vec == NULL)
 373     {
 374       _bfd_delete_bfd (nbfd);
 375       return NULL;
 376     }
 377
 378   nbfd->filename = filename;
 379   nbfd->direction = write_direction;
 380
 381   if (bfd_open_file (nbfd) == NULL)
 382     {
 383       /* File not writeable, etc.  */
 384       bfd_set_error (bfd_error_system_call);
 385       _bfd_delete_bfd (nbfd);
 386       return NULL;
 387   }
 388
 389   return nbfd;
 390 }
 391
 392 /*
 393
 394 FUNCTION
 395         bfd_close
 396
 397 SYNOPSIS
 398         bfd_boolean bfd_close (bfd *abfd);
 399
 400 DESCRIPTION
 401
 402         Close a BFD. If the BFD was open for writing, then pending
 403         operations are completed and the file written out and closed.
 404         If the created file is executable, then <<chmod>> is called
 405         to mark it as such.
 406
 407         All memory attached to the BFD is released.
 408
 409         The file descriptor associated with the BFD is closed (even
 410         if it was passed in to BFD by <<bfd_fdopenr>>).
 411
 412 RETURNS
 413         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 414 */
 415
 416
 417 bfd_boolean
 418 bfd_close (abfd)
 419      bfd *abfd;
 420 {
 421   bfd_boolean ret;
 422
 423   if (bfd_write_p (abfd))
 424     {
 425       if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 426         return FALSE;
 427     }
 428
 429   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 430     return FALSE;
 431
 432   ret = bfd_cache_close (abfd);
 433
 434   /* If the file was open for writing and is now executable,
 435      make it so.  */
 436   if (ret
 437       && abfd->direction == write_direction
 438       && abfd->flags & EXEC_P)
 439     {
 440       struct stat buf;
 441
 442       if (stat (abfd->filename, &buf) == 0)
 443         {
 444           unsigned int mask = umask (0);
 445
 446           umask (mask);
 447           chmod (abfd->filename,
 448                  (0777
 449                   & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
 450         }
 451     }
 452
 453   _bfd_delete_bfd (abfd);
 454
 455   return ret;
 456 }
 457
 458 /*
 459 FUNCTION
 460         bfd_close_all_done
 461
 462 SYNOPSIS
 463         bfd_boolean bfd_close_all_done (bfd *);
 464
 465 DESCRIPTION
 466         Close a BFD.  Differs from <<bfd_close>> since it does not
 467         complete any pending operations.  This routine would be used
 468         if the application had just used BFD for swapping and didn't
 469         want to use any of the writing code.
 470
 471         If the created file is executable, then <<chmod>> is called
 472         to mark it as such.
 473
 474         All memory attached to the BFD is released.
 475
 476 RETURNS
 477         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 478 */
 479
 480 bfd_boolean
 481 bfd_close_all_done (abfd)
 482      bfd *abfd;
 483 {
 484   bfd_boolean ret;
 485
 486   ret = bfd_cache_close (abfd);
 487
 488   /* If the file was open for writing and is now executable,
 489      make it so.  */
 490   if (ret
 491       && abfd->direction == write_direction
 492       && abfd->flags & EXEC_P)
 493     {
 494       struct stat buf;
 495
 496       if (stat (abfd->filename, &buf) == 0)
 497         {
 498           unsigned int mask = umask (0);
 499
 500           umask (mask);
 501           chmod (abfd->filename,
 502                  (0777
 503                   & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
 504         }
 505     }
 506
 507   _bfd_delete_bfd (abfd);
 508
 509   return ret;
 510 }
 511
 512 /*
 513 FUNCTION
 514         bfd_create
 515
 516 SYNOPSIS
 517         bfd *bfd_create(const char *filename, bfd *templ);
 518
 519 DESCRIPTION
 520         Create a new BFD in the manner of <<bfd_openw>>, but without
 521         opening a file. The new BFD takes the target from the target
 522         used by @var{template}. The format is always set to <<bfd_object>>.
 523 */
 524
 525 bfd *
 526 bfd_create (filename, templ)
 527      const char *filename;
 528      bfd *templ;
 529 {
 530   bfd *nbfd;
 531
 532   nbfd = _bfd_new_bfd ();
 533   if (nbfd == NULL)
 534     return NULL;
 535   nbfd->filename = filename;
 536   if (templ)
 537     nbfd->xvec = templ->xvec;
 538   nbfd->direction = no_direction;
 539   bfd_set_format (nbfd, bfd_object);
 540
 541   return nbfd;
 542 }
 543
 544 /*
 545 FUNCTION
 546         bfd_make_writable
 547
 548 SYNOPSIS
 549         bfd_boolean bfd_make_writable (bfd *abfd);
 550
 551 DESCRIPTION
 552         Takes a BFD as created by <<bfd_create>> and converts it
 553         into one like as returned by <<bfd_openw>>.  It does this
 554         by converting the BFD to BFD_IN_MEMORY.  It's assumed that
 555         you will call <<bfd_make_readable>> on this bfd later.
 556
 557 RETURNS
 558         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
 559 */
 560
 561 bfd_boolean
 562 bfd_make_writable(abfd)
 563      bfd *abfd;
 564 {
 565   struct bfd_in_memory *bim;
 566
 567   if (abfd->direction != no_direction)
 568     {
 569       bfd_set_error (bfd_error_invalid_operation);
 570       return FALSE;
 571     }
 572
 573   bim = ((struct bfd_in_memory *)
 574          bfd_malloc ((bfd_size_type) sizeof (struct bfd_in_memory)));
 575   abfd->iostream = (PTR) bim;
 576   /* bfd_bwrite will grow these as needed.  */
 577   bim->size = 0;
 578   bim->buffer = 0;
 579
 580   abfd->flags |= BFD_IN_MEMORY;
 581   abfd->direction = write_direction;
 582   abfd->where = 0;
 583
 584   return TRUE;
 585 }
 586
 587 /*
 588 FUNCTION
 589         bfd_make_readable
 590
 591 SYNOPSIS
 592         bfd_boolean bfd_make_readable (bfd *abfd);
 593
 594 DESCRIPTION
 595         Takes a BFD as created by <<bfd_create>> and
 596         <<bfd_make_writable>> and converts it into one like as
 597         returned by <<bfd_openr>>.  It does this by writing the
 598         contents out to the memory buffer, then reversing the
 599         direction.
 600
 601 RETURNS
 602         <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
 603
 604 bfd_boolean
 605 bfd_make_readable(abfd)
 606      bfd *abfd;
 607 {
 608   if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
 609     {
 610       bfd_set_error (bfd_error_invalid_operation);
 611       return FALSE;
 612     }
 613
 614   if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
 615     return FALSE;
 616
 617   if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
 618     return FALSE;
 619
 620
 621   abfd->arch_info = &bfd_default_arch_struct;
 622
 623   abfd->where = 0;
 624   abfd->format = bfd_unknown;
 625   abfd->my_archive = (bfd *) NULL;
 626   abfd->origin = 0;
 627   abfd->opened_once = FALSE;
 628   abfd->output_has_begun = FALSE;
 629   abfd->section_count = 0;
 630   abfd->usrdata = (PTR) NULL;
 631   abfd->cacheable = FALSE;
 632   abfd->flags = BFD_IN_MEMORY;
 633   abfd->mtime_set = FALSE;
 634
 635   abfd->target_defaulted = TRUE;
 636   abfd->direction = read_direction;
 637   abfd->sections = 0;
 638   abfd->symcount = 0;
 639   abfd->outsymbols = 0;
 640   abfd->tdata.any = 0;
 641
 642   bfd_section_list_clear (abfd);
 643   bfd_check_format (abfd, bfd_object);
 644
 645   return TRUE;
 646 }
 647
 648 /*
 649 INTERNAL_FUNCTION
 650         bfd_alloc
 651
 652 SYNOPSIS
 653         PTR bfd_alloc (bfd *abfd, size_t wanted);
 654
 655 DESCRIPTION
 656         Allocate a block of @var{wanted} bytes of memory attached to
 657         <<abfd>> and return a pointer to it.
 658 */
 659
 660
 661 PTR
 662 bfd_alloc (abfd, size)
 663      bfd *abfd;
 664      bfd_size_type size;
 665 {
 666   PTR ret;
 667
 668   if (size != (unsigned long) size)
 669     {
 670       bfd_set_error (bfd_error_no_memory);
 671       return NULL;
 672     }
 673
 674   ret = objalloc_alloc (abfd->memory, (unsigned long) size);
 675   if (ret == NULL)
 676     bfd_set_error (bfd_error_no_memory);
 677   return ret;
 678 }
 679
 680 PTR
 681 bfd_zalloc (abfd, size)
 682      bfd *abfd;
 683      bfd_size_type size;
 684 {
 685   PTR res;
 686
 687   res = bfd_alloc (abfd, size);
 688   if (res)
 689     memset (res, 0, (size_t) size);
 690   return res;
 691 }
 692
 693 /* Free a block allocated for a BFD.
 694    Note:  Also frees all more recently allocated blocks!  */
 695
 696 void
 697 bfd_release (abfd, block)
 698      bfd *abfd;
 699      PTR block;
 700 {
 701   objalloc_free_block ((struct objalloc *) abfd->memory, block);
 702 }
 703
 704
 705 /*
 706    GNU Extension: separate debug-info files
 707
 708    The idea here is that a special section called .gnu_debuglink might be
 709    embedded in a binary file, which indicates that some *other* file
 710    contains the real debugging information. This special section contains a
 711    filename and CRC32 checksum, which we read and resolve to another file,
 712    if it exists.
 713
 714    This facilitates "optional" provision of debugging information, without
 715    having to provide two complete copies of every binary object (with and
 716    without debug symbols).
 717 */
 718
 719 static char *         get_debug_link_info         PARAMS ((bfd *, unsigned long *));
 720 static bfd_boolean    separate_debug_file_exists  PARAMS ((const char *, const unsigned long));
 721 static char *         find_separate_debug_file    PARAMS ((bfd *, const char *));
 722
 723 #define GNU_DEBUGLINK   ".gnu_debuglink"
 724 /*
 725 FUNCTION
 726         bfd_calc_gnu_debuglink_crc32
 727
 728 SYNOPSIS
 729         unsigned long bfd_calc_gnu_debuglink_crc32 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
 730
 731 DESCRIPTION
 732         Computes a CRC value as used in the .gnu_debuglink section.
 733         Advances the previously computed @var{crc} value by computing
 734         and adding in the crc32 for @var{len} bytes of @var{buf}.
 735
 736 RETURNS
 737         Return the updated CRC32 value.
 738 */
 739
 740 unsigned long
 741 bfd_calc_gnu_debuglink_crc32 (crc, buf, len)
 742      unsigned long crc;
 743      const unsigned char *buf;
 744      bfd_size_type len;
 745 {
 746   static const unsigned long crc32_table[256] =
 747     {
 748       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
 749       0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
 750       0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
 751       0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
 752       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
 753       0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
 754       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
 755       0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
 756       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
 757       0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
 758       0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
 759       0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
 760       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
 761       0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
 762       0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
 763       0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
 764       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
 765       0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
 766       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
 767       0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
 768       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
 769       0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
 770       0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
 771       0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
 772       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
 773       0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
 774       0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
 775       0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
 776       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
 777       0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
 778       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
 779       0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
 780       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
 781       0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
 782       0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
 783       0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
 784       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
 785       0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
 786       0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
 787       0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
 788       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
 789       0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
 790       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
 791       0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
 792       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
 793       0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
 794       0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
 795       0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
 796       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
 797       0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
 798       0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
 799       0x2d02ef8d
 800     };
 801   const unsigned char *end;
 802
 803   crc = ~crc & 0xffffffff;
 804   for (end = buf + len; buf < end; ++ buf)
 805     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
 806   return ~crc & 0xffffffff;;
 807 }
 808
 809
 810 /*
 811 INTERNAL_FUNCTION
 812         get_debug_link_info
 813
 814 SYNOPSIS
 815         char * get_debug_link_info (bfd * abfd, unsigned long * crc32_out)
 816
 817 DESCRIPTION
 818         fetch the filename and CRC32 value for any separate debuginfo
 819         associated with @var{abfd}. Return NULL if no such info found,
 820         otherwise return filename and update @var{crc32_out}.
 821 */
 822
 823 static char *
 824 get_debug_link_info (abfd, crc32_out)
 825      bfd * abfd;
 826      unsigned long * crc32_out;
 827 {
 828   asection * sect;
 829   bfd_size_type debuglink_size;
 830   unsigned long crc32;
 831   char * contents;
 832   int crc_offset;
 833   bfd_boolean ret;
 834
 835   BFD_ASSERT (abfd);
 836   BFD_ASSERT (crc32_out);
 837
 838   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
 839
 840   if (sect == NULL)
 841     return NULL;
 842
 843   debuglink_size = bfd_section_size (abfd, sect);
 844
 845   contents = malloc (debuglink_size);
 846   if (contents == NULL)
 847     return NULL;
 848
 849   ret = bfd_get_section_contents (abfd, sect, contents,
 850                                   (file_ptr)0, debuglink_size);
 851   if (! ret)
 852     {
 853       free (contents);
 854       return NULL;
 855     }
 856
 857   /* Crc value is stored after the filename, aligned up to 4 bytes.  */
 858   crc_offset = strlen (contents) + 1;
 859   crc_offset = (crc_offset + 3) & ~3;
 860
 861   crc32 = bfd_get_32 (abfd, (bfd_byte *) (contents + crc_offset));
 862
 863   *crc32_out = crc32;
 864   return contents;
 865 }
 866
 867 /*
 868 INTERNAL_FUNCTION
 869         separate_debug_file_exists
 870
 871 SYNOPSIS
 872         bfd_boolean separate_debug_file_exists (char * name, unsigned long crc32)
 873
 874 DESCRIPTION
 875         Checks to see if @var{name} is a file and if its contents
 876         match @var{crc32}.
 877 */
 878
 879 static bfd_boolean
 880 separate_debug_file_exists (name, crc)
 881      const char *name;
 882      const unsigned long crc;
 883 {
 884   static char buffer [8 * 1024];
 885   unsigned long file_crc = 0;
 886   int fd;
 887   bfd_size_type count;
 888
 889   BFD_ASSERT (name);
 890
 891   fd = open (name, O_RDONLY);
 892   if (fd < 0)
 893     return FALSE;
 894
 895   while ((count = read (fd, buffer, sizeof (buffer))) > 0)
 896     file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
 897
 898   close (fd);
 899
 900   return crc == file_crc;
 901 }
 902
 903
 904 /*
 905 INTERNAL_FUNCTION
 906         find_separate_debug_file
 907
 908 SYNOPSIS
 909         char * find_separate_debug_file (bfd *abfd)
 910
 911 DESCRIPTION
 912         Searches @var{abfd} for a reference to separate debugging
 913         information, scans various locations in the filesystem, including
 914         the file tree rooted at @var{debug_file_directory}, and returns a
 915         filename of such debugging information if the file is found and has
 916         matching CRC32.  Returns NULL if no reference to debugging file
 917         exists, or file cannot be found.
 918 */
 919
 920 static char *
 921 find_separate_debug_file (abfd, debug_file_directory)
 922      bfd *abfd;
 923      const char *debug_file_directory;
 924 {
 925   char *basename;
 926   char *dir;
 927   char *debugfile;
 928   unsigned long crc32;
 929   int i;
 930
 931   BFD_ASSERT (abfd);
 932   if (debug_file_directory == NULL)
 933     debug_file_directory = ".";
 934
 935   /* BFD may have been opened from a stream.  */
 936   if (! abfd->filename)
 937     return NULL;
 938
 939   basename = get_debug_link_info (abfd, & crc32);
 940   if (basename == NULL)
 941     return NULL;
 942
 943   if (strlen (basename) < 1)
 944     {
 945       free (basename);
 946       return NULL;
 947     }
 948
 949   dir = strdup (abfd->filename);
 950   if (dir == NULL)
 951     {
 952       free (basename);
 953       return NULL;
 954     }
 955   BFD_ASSERT (strlen (dir) != 0);
 956
 957   /* Strip off filename part.  */
 958   for (i = strlen (dir) - 1; i >= 0; i--)
 959     if (IS_DIR_SEPARATOR (dir[i]))
 960       break;
 961
 962   dir[i + 1] = '\0';
 963   BFD_ASSERT (dir[i] == '/' || dir[0] == '\0')
 964
 965   debugfile = malloc (strlen (debug_file_directory) + 1
 966                       + strlen (dir)
 967                       + strlen (".debug/")
 968                       + strlen (basename)
 969                       + 1);
 970   if (debugfile == NULL)
 971     {
 972       free (basename);
 973       free (dir);
 974       return NULL;
 975     }
 976
 977   /* First try in the same directory as the original file:  */
 978   strcpy (debugfile, dir);
 979   strcat (debugfile, basename);
 980
 981   if (separate_debug_file_exists (debugfile, crc32))
 982     {
 983       free (basename);
 984       free (dir);
 985       return debugfile;
 986     }
 987
 988   /* Then try in a subdirectory called .debug.  */
 989   strcpy (debugfile, dir);
 990   strcat (debugfile, ".debug/");
 991   strcat (debugfile, basename);
 992
 993   if (separate_debug_file_exists (debugfile, crc32))
 994     {
 995       free (basename);
 996       free (dir);
 997       return debugfile;
 998     }
 999
1000   /* Then try in the global debugfile directory.  */
1001   strcpy (debugfile, debug_file_directory);
1002   i = strlen (debug_file_directory) - 1;
1003   if (i > 0
1004       && debug_file_directory[i] != '/'
1005       && dir[0] != '/')
1006     strcat (debugfile, "/");
1007   strcat (debugfile, dir);
1008   strcat (debugfile, basename);
1009
1010   if (separate_debug_file_exists (debugfile, crc32))
1011     {
1012       free (basename);
1013       free (dir);
1014       return debugfile;
1015     }
1016
1017   free (debugfile);
1018   free (basename);
1019   free (dir);
1020   return NULL;
1021 }
1022
1023
1024 /*
1025 FUNCTION
1026         bfd_follow_gnu_debuglink
1027
1028 SYNOPSIS
1029         char * bfd_follow_gnu_debuglink(bfd *abfd, const char *dir);
1030
1031 DESCRIPTION
1032
1033         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1034         section is found, examines the section for the name and checksum of
1035         a '.debug' file containing auxiliary debugging
1036         information. Searches filesystem for .debug file in some standard
1037         locations, including the directory tree rooted at @var{dir}, and if
1038         found returns the full filename. If @var{dir} is NULL, will search
1039         default path configured into libbfd at build time.
1040
1041 RETURNS
1042         <<NULL>> on any errors or failure to locate the .debug file,
1043         otherwise a pointer to a heap-allocated string containing the
1044         filename. The caller is responsible for freeing this string.
1045 */
1046
1047 char *
1048 bfd_follow_gnu_debuglink (abfd, dir)
1049      bfd *abfd;
1050      const char * dir;
1051 {
1052 #if 0 /* Disabled until DEBUGDIR can be defined by configure.in  */
1053   if (dir == NULL)
1054     dir = DEBUGDIR;
1055 #endif
1056   return find_separate_debug_file (abfd, dir);
1057 }
1058
1059 /*
1060 FUNCTION
1061         bfd_add_gnu_debuglink
1062
1063 SYNOPSIS
1064         bfd_boolean bfd_add_gnu_debuglink (bfd * abfd, const char * filename);
1065
1066 DESCRIPTION
1067
1068         Takes a @var{BFD} and adds a .gnu_debuglink section containing a link
1069         to the specified @var{filename}.  The filename should be relative to
1070         the current directory.
1071
1072 RETURNS
1073         <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1074         and bfd_error is set.
1075 */
1076
1077 bfd_boolean
1078 bfd_add_gnu_debuglink (abfd, filename)
1079      bfd *abfd;
1080      const char * filename;
1081 {
1082   asection * sect;
1083   bfd_size_type debuglink_size;
1084   unsigned long crc32;
1085   char * contents;
1086   bfd_size_type crc_offset;
1087   FILE * handle;
1088   static char buffer[8 * 1024];
1089   size_t count;
1090
1091   if (abfd == NULL || filename == NULL)
1092     {
1093       bfd_set_error (bfd_error_invalid_operation);
1094       return FALSE;
1095     }
1096
1097   /* Make sure that we can read the file.
1098      XXX - Should we attempt to locate the debug info file using the same
1099      algorithm as gdb ?  At the moment, since we are creating the
1100      .gnu_debuglink section, we insist upon the user providing us with a
1101      correct-for-section-creation-time path, but this need not conform to
1102      the gdb location algorithm.  */
1103   handle = fopen (filename, FOPEN_RB);
1104   if (handle == NULL)
1105     {
1106       bfd_set_error (bfd_error_system_call);
1107       return FALSE;
1108     }
1109
1110   crc32 = 0;
1111   while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1112     crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1113   fclose (handle);
1114
1115   /* Strip off any path components in filename,
1116      now that we no longer need them.  */
1117   filename = lbasename (filename);
1118
1119   sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1120   if (sect)
1121     {
1122       /* Section already exists.  */
1123       bfd_set_error (bfd_error_invalid_operation);
1124       return FALSE;
1125     }
1126
1127   sect = bfd_make_section (abfd, GNU_DEBUGLINK);
1128   if (sect == NULL)
1129     return FALSE;
1130
1131   if (! bfd_set_section_flags (abfd, sect,
1132                                SEC_HAS_CONTENTS | SEC_DEBUGGING))
1133     /* XXX Should we delete the section from the bfd ?  */
1134     return FALSE;
1135
1136
1137   debuglink_size = strlen (filename) + 1;
1138   debuglink_size += 3;
1139   debuglink_size &= ~3;
1140   debuglink_size += 4;
1141
1142   if (! bfd_set_section_size (abfd, sect, debuglink_size))
1143     /* XXX Should we delete the section from the bfd ?  */
1144     return FALSE;
1145
1146   contents = malloc (debuglink_size);
1147   if (contents == NULL)
1148     {
1149       /* XXX Should we delete the section from the bfd ?  */
1150       bfd_set_error (bfd_error_no_memory);
1151       return FALSE;
1152     }
1153
1154   strcpy (contents, filename);
1155   crc_offset = debuglink_size - 4;
1156
1157   bfd_put_32 (abfd, crc32, (bfd_byte *) (contents + crc_offset));
1158
1159   if (! bfd_set_section_contents (abfd, sect, contents,
1160                                   (file_ptr)0, debuglink_size))
1161     {
1162       /* XXX Should we delete the section from the bfd ?  */
1163       free (contents);
1164       return FALSE;
1165     }
1166
1167   return TRUE;
1168 }