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