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