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 unsigned long  calc_crc32                  PARAMS ((unsigned long, const unsigned char *, size_t));
 720 static char *         get_debug_link_info         PARAMS ((bfd *, unsigned long *));
 721 static bfd_boolean    separate_debug_file_exists  PARAMS ((const char *, const unsigned long));
 722 static char *         find_separate_debug_file    PARAMS ((bfd *, const char *));
 723
 724 /*
 725 INTERNAL_FUNCTION
 726         calc_crc32
 727
 728 SYNOPSIS
 729         unsigned long calc_crc32 (unsigned long crc, const unsigned char *buf, size_t len);
 730
 731 DESCRIPTION
 732         Advance the CRC32 given by @var{crc} through @var{len}
 733         bytes of @var{buf}. Return the updated CRC32 value.
 734 */
 735
 736 static unsigned long
 737 calc_crc32 (crc, buf, len)
 738      unsigned long crc;
 739      const unsigned char *buf;
 740      size_t len;
 741 {
 742   static const unsigned long crc32_table[256] =
 743     {
 744       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
 745       0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
 746       0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
 747       0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
 748       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
 749       0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
 750       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
 751       0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
 752       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
 753       0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
 754       0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
 755       0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
 756       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
 757       0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
 758       0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
 759       0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
 760       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
 761       0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
 762       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
 763       0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
 764       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
 765       0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
 766       0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
 767       0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
 768       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
 769       0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
 770       0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
 771       0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
 772       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
 773       0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
 774       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
 775       0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
 776       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
 777       0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
 778       0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
 779       0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
 780       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
 781       0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
 782       0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
 783       0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
 784       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
 785       0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
 786       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
 787       0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
 788       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
 789       0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
 790       0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
 791       0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
 792       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
 793       0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
 794       0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
 795       0x2d02ef8d
 796     };
 797   const unsigned char *end;
 798
 799   crc = ~crc & 0xffffffff;
 800   for (end = buf + len; buf < end; ++ buf)
 801     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
 802   return ~crc & 0xffffffff;;
 803 }
 804
 805
 806 /*
 807 INTERNAL_FUNCTION
 808         get_debug_link_info
 809
 810 SYNOPSIS
 811         char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
 812
 813 DESCRIPTION
 814         fetch the filename and CRC32 value for any separate debuginfo
 815         associated with @var{abfd}. Return NULL if no such info found,
 816         otherwise return filename and update @var{crc32_out}.
 817 */
 818
 819 static char *
 820 get_debug_link_info (abfd, crc32_out)
 821      bfd *abfd;
 822      unsigned long *crc32_out;
 823 {
 824   asection * sect;
 825   bfd_size_type debuglink_size;
 826   unsigned long crc32;
 827   char * contents;
 828   int crc_offset;
 829   bfd_boolean ret;
 830
 831   BFD_ASSERT (abfd);
 832   BFD_ASSERT (crc32_out);
 833
 834   sect = bfd_get_section_by_name (abfd, ".gnu_debuglink");
 835
 836   if (sect == NULL)
 837     return NULL;
 838
 839   debuglink_size = bfd_section_size (abfd, sect);
 840
 841   contents = xmalloc (debuglink_size);
 842   ret = bfd_get_section_contents (abfd, sect, contents,
 843                                   (file_ptr)0, debuglink_size);
 844   if (! ret)
 845     {
 846       free (contents);
 847       return NULL;
 848     }
 849
 850   /* Crc value is stored after the filename, aligned up to 4 bytes.  */
 851   crc_offset = strlen (contents) + 1;
 852   crc_offset = (crc_offset + 3) & ~3;
 853
 854   crc32 = bfd_get_32 (abfd, (bfd_byte *) (contents + crc_offset));
 855
 856   *crc32_out = crc32;
 857   return contents;
 858 }
 859
 860 /*
 861 INTERNAL_FUNCTION
 862         separate_debug_file_exists
 863
 864 SYNOPSIS
 865         bfd_boolean separate_debug_file_exists (char * name, unsigned long crc32)
 866
 867 DESCRIPTION
 868         Checks to see if @var{name} is a file and if its contents
 869         match @var{crc32}.
 870 */
 871
 872 static bfd_boolean
 873 separate_debug_file_exists (name, crc)
 874      const char *name;
 875      const unsigned long crc;
 876 {
 877   static char buffer [8 * 1024];
 878   unsigned long file_crc = 0;
 879   int fd;
 880   int count;
 881
 882   BFD_ASSERT (name);
 883
 884   fd = open (name, O_RDONLY);
 885   if (fd < 0)
 886     return FALSE;
 887
 888   while ((count = read (fd, buffer, sizeof (buffer))) > 0)
 889     file_crc = calc_crc32 (file_crc, buffer, count);
 890
 891   close (fd);
 892
 893   return crc == file_crc;
 894 }
 895
 896
 897 /*
 898 INTERNAL_FUNCTION
 899         find_separate_debug_file
 900
 901 SYNOPSIS
 902         char * find_separate_debug_file (bfd *abfd)
 903
 904 DESCRIPTION
 905         Searches @var{abfd} for a reference to separate debugging
 906         information, scans various locations in the filesystem, including
 907         the file tree rooted at @var{debug_file_directory}, and returns a
 908         filename of such debugging information if the file is found and has
 909         matching CRC32.  Returns NULL if no reference to debugging file
 910         exists, or file cannot be found.
 911 */
 912
 913 static char *
 914 find_separate_debug_file (abfd, debug_file_directory)
 915      bfd *abfd;
 916      const char *debug_file_directory;
 917 {
 918   char *basename;
 919   char *dir;
 920   char *debugfile;
 921   unsigned long crc32;
 922   int i;
 923
 924   BFD_ASSERT (abfd);
 925   if (debug_file_directory == NULL)
 926     debug_file_directory = ".";
 927
 928   /* BFD may have been opened from a stream.  */
 929   if (! abfd->filename)
 930     return NULL;
 931
 932   basename = get_debug_link_info (abfd, & crc32);
 933
 934   if (basename == NULL)
 935     return NULL;
 936   if (strlen (basename) < 1)
 937     {
 938       free (basename);
 939       return NULL;
 940     }
 941
 942   dir = xstrdup (abfd->filename);
 943   BFD_ASSERT (strlen (dir) != 0);
 944
 945   /* Strip off filename part.  */
 946   for (i = strlen (dir) - 1; i >= 0; i--)
 947     if (IS_DIR_SEPARATOR (dir[i]))
 948       break;
 949
 950   dir[i + 1] = '\0';
 951   BFD_ASSERT (dir[i] == '/' || dir[0] == '\0')
 952
 953   debugfile = xmalloc (strlen (debug_file_directory) + 1
 954                        + strlen (dir)
 955                        + strlen (".debug/")
 956                        + strlen (basename)
 957                        + 1);
 958
 959   /* First try in the same directory as the original file:  */
 960   strcpy (debugfile, dir);
 961   strcat (debugfile, basename);
 962
 963   if (separate_debug_file_exists (debugfile, crc32))
 964     {
 965       free (basename);
 966       free (dir);
 967       return debugfile;
 968     }
 969
 970   /* Then try in a subdirectory called .debug.  */
 971   strcpy (debugfile, dir);
 972   strcat (debugfile, ".debug/");
 973   strcat (debugfile, basename);
 974
 975   if (separate_debug_file_exists (debugfile, crc32))
 976     {
 977       free (basename);
 978       free (dir);
 979       return debugfile;
 980     }
 981
 982   /* Then try in the global debugfile directory.  */
 983   strcpy (debugfile, debug_file_directory);
 984   i = strlen (debug_file_directory) - 1;
 985   if (i > 0
 986       && debug_file_directory[i] != '/'
 987       && dir[0] != '/')
 988     strcat (debugfile, "/");
 989   strcat (debugfile, dir);
 990   strcat (debugfile, basename);
 991
 992   if (separate_debug_file_exists (debugfile, crc32))
 993     {
 994       free (basename);
 995       free (dir);
 996       return debugfile;
 997     }
 998
 999   free (debugfile);
1000   free (basename);
1001   free (dir);
1002   return NULL;
1003 }
1004
1005
1006 /*
1007 FUNCTION
1008         bfd_follow_gnu_debuglink
1009
1010 SYNOPSIS
1011         char * bfd_follow_gnu_debuglink(bfd *abfd, const char *dir);
1012
1013 DESCRIPTION
1014
1015         Takes a BFD and searches it for a .gnu_debuglink section.  If this
1016         section is found, examines the section for the name and checksum of
1017         a '.debug' file containing auxiliary debugging
1018         information. Searches filesystem for .debug file in some standard
1019         locations, including the directory tree rooted at @var{dir}, and if
1020         found returns the full filename. If @var{dir} is NULL, will search
1021         default path configured into libbfd at build time.
1022
1023 RETURNS
1024         <<NULL>> on any errors or failure to locate the .debug file,
1025         otherwise a pointer to a heap-allocated string containing the
1026         filename. The caller is responsible for freeing this string.
1027 */
1028
1029 char *
1030 bfd_follow_gnu_debuglink (abfd, dir)
1031      bfd *abfd;
1032      const char * dir;
1033 {
1034 #if 0 /* Disabled until DEBUGDIR can be defined by configure.in  */
1035   if (dir == NULL)
1036     dir = DEBUGDIR;
1037 #endif
1038   return find_separate_debug_file (abfd, dir);
1039 }