1/* opncls.c -- open and close a BFD. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 3 2001, 2002, 2003, 2004 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 42static 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 49bfd * 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 97bfd * 98_bfd_new_bfd_contained_in (bfd *obfd) 99{ 100 bfd *nbfd; 101 102 nbfd = _bfd_new_bfd (); 103 if (nbfd == NULL) 104 return NULL; 105 nbfd->xvec = obfd->xvec; 106 nbfd->iovec = obfd->iovec; 107 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 115void 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/* 124SECTION 125 Opening and closing BFDs 126 127*/ 128 129/* 130FUNCTION 131 bfd_openr 132 133SYNOPSIS 134 bfd *bfd_openr (const char *filename, const char *target); 135 136DESCRIPTION 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 148bfd * 149bfd_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/* 187FUNCTION 188 bfd_fdopenr 189 190SYNOPSIS 191 bfd *bfd_fdopenr (const char *filename, const char *target, int fd); 192 193DESCRIPTION 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 caching; 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 212bfd * 213bfd_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/* 284FUNCTION 285 bfd_openstreamr 286 287SYNOPSIS 288 bfd *bfd_openstreamr (const char *, const char *, void *); 289 290DESCRIPTION 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 296bfd * 297bfd_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 327/* 328FUNCTION 329 bfd_openr_iovec 330 331SYNOPSIS 332 bfd *bfd_openr_iovec (const char *filename, const char *target, 333 void *(*open) (struct bfd *nbfd, 334 void *open_closure), 335 void *open_closure, 336 file_ptr (*pread) (struct bfd *nbfd, 337 void *stream, 338 void *buf, 339 file_ptr nbytes, 340 file_ptr offset), 341 int (*close) (struct bfd *nbfd, 342 void *stream)); 343 344DESCRIPTION 345 346 Create and return a BFD backed by a read-only @var{stream}. 347 The @var{stream} is created using @var{open}, accessed using 348 @var{pread} and destroyed using @var{close}. 349 350 Calls <<bfd_find_target>>, so @var{target} is interpreted as by 351 that function. 352 353 Calls @var{open} (which can call <<bfd_zalloc>> and 354 <<bfd_get_filename>>) to obtain the read-only stream backing 355 the BFD. @var{open} either succeeds returning the 356 non-<<NULL>> @var{stream}, or fails returning <<NULL>> 357 (setting <<bfd_error>>). 358 359 Calls @var{pread} to request @var{nbytes} of data from 360 @var{stream} starting at @var{offset} (e.g., via a call to 361 <<bfd_read>>). @var{pread} either succeeds returning the 362 number of bytes read (which can be less than @var{nbytes} when 363 end-of-file), or fails returning -1 (setting <<bfd_error>>). 364 365 Calls @var{close} when the BFD is later closed using 366 <<bfd_close>>. @var{close} either succeeds returning 0, or 367 fails returning -1 (setting <<bfd_error>>). 368 369 If <<bfd_openr_iovec>> returns <<NULL>> then an error has 370 occurred. Possible errors are <<bfd_error_no_memory>>, 371 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>. 372 373*/ 374 375struct opncls 376{ 377 void *stream; 378 file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf, 379 file_ptr nbytes, file_ptr offset); 380 int (*close) (struct bfd *abfd, void *stream); 381 file_ptr where; 382}; 383 384static file_ptr 385opncls_btell (struct bfd *abfd) 386{ 387 struct opncls *vec = abfd->iostream; 388 return vec->where; 389} 390 391static int 392opncls_bseek (struct bfd *abfd, file_ptr offset, int whence) 393{ 394 struct opncls *vec = abfd->iostream; 395 switch (whence) 396 { 397 case SEEK_SET: vec->where = offset; break; 398 case SEEK_CUR: vec->where += offset; break; 399 case SEEK_END: return -1; 400 } 401 return 0; 402} 403 404static file_ptr 405opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes) 406{ 407 struct opncls *vec = abfd->iostream; 408 file_ptr nread = vec->pread (abfd, vec->stream, buf, nbytes, vec->where); 409 if (nread < 0) 410 return nread; 411 vec->where += nread; 412 return nread; 413} 414 415static file_ptr 416opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED, 417 const void *where ATTRIBUTE_UNUSED, 418 file_ptr nbytes ATTRIBUTE_UNUSED) 419{ 420 return -1; 421} 422 423static int 424opncls_bclose (struct bfd *abfd) 425{ 426 struct opncls *vec = abfd->iostream; 427 /* Since the VEC's memory is bound to the bfd deleting the bfd will 428 free it. */ 429 int status = 0; 430 if (vec->close != NULL) 431 status = vec->close (abfd, vec->stream); 432 abfd->iostream = NULL; 433 return status; 434} 435 436static int 437opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED) 438{ 439 return 0; 440} 441 442static int 443opncls_bstat (struct bfd *abfd ATTRIBUTE_UNUSED, struct stat *sb) 444{ 445 memset (sb, 0, sizeof (*sb)); 446 return 0; 447} 448 449static const struct bfd_iovec opncls_iovec = { 450 &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek, 451 &opncls_bclose, &opncls_bflush, &opncls_bstat 452}; 453 454bfd * 455bfd_openr_iovec (const char *filename, const char *target, 456 void *(*open) (struct bfd *nbfd, 457 void *open_closure), 458 void *open_closure, 459 file_ptr (*pread) (struct bfd *abfd, 460 void *stream, 461 void *buf, 462 file_ptr nbytes, 463 file_ptr offset), 464 int (*close) (struct bfd *nbfd, 465 void *stream)) 466{ 467 bfd *nbfd; 468 const bfd_target *target_vec; 469 struct opncls *vec; 470 void *stream; 471 472 nbfd = _bfd_new_bfd (); 473 if (nbfd == NULL) 474 return NULL; 475 476 target_vec = bfd_find_target (target, nbfd); 477 if (target_vec == NULL) 478 { 479 _bfd_delete_bfd (nbfd); 480 return NULL; 481 } 482 483 nbfd->filename = filename; 484 nbfd->direction = read_direction; 485 486 stream = open (nbfd, open_closure); 487 if (stream == NULL) 488 { 489 _bfd_delete_bfd (nbfd); 490 return NULL; 491 } 492 493 vec = bfd_zalloc (nbfd, sizeof (struct opncls)); 494 vec->stream = stream; 495 vec->pread = pread; 496 vec->close = close; 497 498 nbfd->iovec = &opncls_iovec; 499 nbfd->iostream = vec; 500 501 return nbfd; 502} 503 504/* bfd_openw -- open for writing. 505 Returns a pointer to a freshly-allocated BFD on success, or NULL. 506 507 See comment by bfd_fdopenr before you try to modify this function. */ 508 509/* 510FUNCTION 511 bfd_openw 512 513SYNOPSIS 514 bfd *bfd_openw (const char *filename, const char *target); 515 516DESCRIPTION 517 Create a BFD, associated with file @var{filename}, using the 518 file format @var{target}, and return a pointer to it. 519 520 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>, 521 <<bfd_error_invalid_target>>. 522*/ 523 524bfd * 525bfd_openw (const char *filename, const char *target) 526{ 527 bfd *nbfd; 528 const bfd_target *target_vec; 529 530 /* nbfd has to point to head of malloc'ed block so that bfd_close may 531 reclaim it correctly. */ 532 nbfd = _bfd_new_bfd (); 533 if (nbfd == NULL) 534 return NULL; 535 536 target_vec = bfd_find_target (target, nbfd); 537 if (target_vec == NULL) 538 { 539 _bfd_delete_bfd (nbfd); 540 return NULL; 541 } 542 543 nbfd->filename = filename; 544 nbfd->direction = write_direction; 545 546 if (bfd_open_file (nbfd) == NULL) 547 { 548 /* File not writeable, etc. */ 549 bfd_set_error (bfd_error_system_call); 550 _bfd_delete_bfd (nbfd); 551 return NULL; 552 } 553 554 return nbfd; 555} 556 557/* 558 559FUNCTION 560 bfd_close 561 562SYNOPSIS 563 bfd_boolean bfd_close (bfd *abfd); 564 565DESCRIPTION 566 567 Close a BFD. If the BFD was open for writing, then pending 568 operations are completed and the file written out and closed. 569 If the created file is executable, then <<chmod>> is called 570 to mark it as such. 571 572 All memory attached to the BFD is released. 573 574 The file descriptor associated with the BFD is closed (even 575 if it was passed in to BFD by <<bfd_fdopenr>>). 576 577RETURNS 578 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. 579*/ 580 581 582bfd_boolean 583bfd_close (bfd *abfd) 584{ 585 bfd_boolean ret; 586 587 if (bfd_write_p (abfd)) 588 { 589 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) 590 return FALSE; 591 } 592 593 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) 594 return FALSE; 595 596 /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io 597 vector. */ 598 if (!(abfd->flags & BFD_IN_MEMORY)) 599 ret = abfd->iovec->bclose (abfd); 600 else 601 ret = 0; 602 603 /* If the file was open for writing and is now executable, 604 make it so. */ 605 if (ret 606 && abfd->direction == write_direction 607 && abfd->flags & EXEC_P) 608 { 609 struct stat buf; 610 611 if (stat (abfd->filename, &buf) == 0) 612 { 613 unsigned int mask = umask (0); 614 615 umask (mask); 616 chmod (abfd->filename, 617 (0777 618 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); 619 } 620 } 621 622 _bfd_delete_bfd (abfd); 623 624 return ret; 625} 626 627/* 628FUNCTION 629 bfd_close_all_done 630 631SYNOPSIS 632 bfd_boolean bfd_close_all_done (bfd *); 633 634DESCRIPTION 635 Close a BFD. Differs from <<bfd_close>> since it does not 636 complete any pending operations. This routine would be used 637 if the application had just used BFD for swapping and didn't 638 want to use any of the writing code. 639 640 If the created file is executable, then <<chmod>> is called 641 to mark it as such. 642 643 All memory attached to the BFD is released. 644 645RETURNS 646 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. 647*/ 648 649bfd_boolean 650bfd_close_all_done (bfd *abfd) 651{ 652 bfd_boolean ret; 653 654 ret = bfd_cache_close (abfd); 655 656 /* If the file was open for writing and is now executable, 657 make it so. */ 658 if (ret 659 && abfd->direction == write_direction 660 && abfd->flags & EXEC_P) 661 { 662 struct stat buf; 663 664 if (stat (abfd->filename, &buf) == 0) 665 { 666 unsigned int mask = umask (0); 667 668 umask (mask); 669 chmod (abfd->filename, 670 (0777 671 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); 672 } 673 } 674 675 _bfd_delete_bfd (abfd); 676 677 return ret; 678} 679 680/* 681FUNCTION 682 bfd_create 683 684SYNOPSIS 685 bfd *bfd_create (const char *filename, bfd *templ); 686 687DESCRIPTION 688 Create a new BFD in the manner of <<bfd_openw>>, but without 689 opening a file. The new BFD takes the target from the target 690 used by @var{template}. The format is always set to <<bfd_object>>. 691*/ 692 693bfd * 694bfd_create (const char *filename, bfd *templ) 695{ 696 bfd *nbfd; 697 698 nbfd = _bfd_new_bfd (); 699 if (nbfd == NULL) 700 return NULL; 701 nbfd->filename = filename; 702 if (templ) 703 nbfd->xvec = templ->xvec; 704 nbfd->direction = no_direction; 705 bfd_set_format (nbfd, bfd_object); 706 707 return nbfd; 708} 709 710/* 711FUNCTION 712 bfd_make_writable 713 714SYNOPSIS 715 bfd_boolean bfd_make_writable (bfd *abfd); 716 717DESCRIPTION 718 Takes a BFD as created by <<bfd_create>> and converts it 719 into one like as returned by <<bfd_openw>>. It does this 720 by converting the BFD to BFD_IN_MEMORY. It's assumed that 721 you will call <<bfd_make_readable>> on this bfd later. 722 723RETURNS 724 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. 725*/ 726 727bfd_boolean 728bfd_make_writable (bfd *abfd) 729{ 730 struct bfd_in_memory *bim; 731 732 if (abfd->direction != no_direction) 733 { 734 bfd_set_error (bfd_error_invalid_operation); 735 return FALSE; 736 } 737 738 bim = bfd_malloc (sizeof (struct bfd_in_memory)); 739 abfd->iostream = bim; 740 /* bfd_bwrite will grow these as needed. */ 741 bim->size = 0; 742 bim->buffer = 0; 743 744 abfd->flags |= BFD_IN_MEMORY; 745 abfd->direction = write_direction; 746 abfd->where = 0; 747 748 return TRUE; 749} 750 751/* 752FUNCTION 753 bfd_make_readable 754 755SYNOPSIS 756 bfd_boolean bfd_make_readable (bfd *abfd); 757 758DESCRIPTION 759 Takes a BFD as created by <<bfd_create>> and 760 <<bfd_make_writable>> and converts it into one like as 761 returned by <<bfd_openr>>. It does this by writing the 762 contents out to the memory buffer, then reversing the 763 direction. 764 765RETURNS 766 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */ 767 768bfd_boolean 769bfd_make_readable (bfd *abfd) 770{ 771 if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY)) 772 { 773 bfd_set_error (bfd_error_invalid_operation); 774 return FALSE; 775 } 776 777 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) 778 return FALSE; 779 780 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) 781 return FALSE; 782 783 784 abfd->arch_info = &bfd_default_arch_struct; 785 786 abfd->where = 0; 787 abfd->format = bfd_unknown; 788 abfd->my_archive = NULL; 789 abfd->origin = 0; 790 abfd->opened_once = FALSE; 791 abfd->output_has_begun = FALSE; 792 abfd->section_count = 0; 793 abfd->usrdata = NULL; 794 abfd->cacheable = FALSE; 795 abfd->flags = BFD_IN_MEMORY; 796 abfd->mtime_set = FALSE; 797 798 abfd->target_defaulted = TRUE; 799 abfd->direction = read_direction; 800 abfd->sections = 0; 801 abfd->symcount = 0; 802 abfd->outsymbols = 0; 803 abfd->tdata.any = 0; 804 805 bfd_section_list_clear (abfd); 806 bfd_check_format (abfd, bfd_object); 807 808 return TRUE; 809} 810 811/* 812INTERNAL_FUNCTION 813 bfd_alloc 814 815SYNOPSIS 816 void *bfd_alloc (bfd *abfd, bfd_size_type wanted); 817 818DESCRIPTION 819 Allocate a block of @var{wanted} bytes of memory attached to 820 <<abfd>> and return a pointer to it. 821*/ 822 823 824void * 825bfd_alloc (bfd *abfd, bfd_size_type size) 826{ 827 void *ret; 828 829 if (size != (unsigned long) size) 830 { 831 bfd_set_error (bfd_error_no_memory); 832 return NULL; 833 } 834 835 ret = objalloc_alloc (abfd->memory, (unsigned long) size); 836 if (ret == NULL) 837 bfd_set_error (bfd_error_no_memory); 838 return ret; 839} 840 841void * 842bfd_zalloc (bfd *abfd, bfd_size_type size) 843{ 844 void *res; 845 846 res = bfd_alloc (abfd, size); 847 if (res) 848 memset (res, 0, (size_t) size); 849 return res; 850} 851 852/* Free a block allocated for a BFD. 853 Note: Also frees all more recently allocated blocks! */ 854 855void 856bfd_release (bfd *abfd, void *block) 857{ 858 objalloc_free_block ((struct objalloc *) abfd->memory, block); 859} 860 861 862/* 863 GNU Extension: separate debug-info files 864 865 The idea here is that a special section called .gnu_debuglink might be 866 embedded in a binary file, which indicates that some *other* file 867 contains the real debugging information. This special section contains a 868 filename and CRC32 checksum, which we read and resolve to another file, 869 if it exists. 870 871 This facilitates "optional" provision of debugging information, without 872 having to provide two complete copies of every binary object (with and 873 without debug symbols). 874*/ 875 876#define GNU_DEBUGLINK ".gnu_debuglink" 877/* 878FUNCTION 879 bfd_calc_gnu_debuglink_crc32 880 881SYNOPSIS 882 unsigned long bfd_calc_gnu_debuglink_crc32 883 (unsigned long crc, const unsigned char *buf, bfd_size_type len); 884 885DESCRIPTION 886 Computes a CRC value as used in the .gnu_debuglink section. 887 Advances the previously computed @var{crc} value by computing 888 and adding in the crc32 for @var{len} bytes of @var{buf}. 889 890RETURNS 891 Return the updated CRC32 value. 892*/ 893 894unsigned long 895bfd_calc_gnu_debuglink_crc32 (unsigned long crc, 896 const unsigned char *buf, 897 bfd_size_type len) 898{ 899 static const unsigned long crc32_table[256] = 900 { 901 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 902 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 903 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 904 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 905 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 906 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 907 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 908 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 909 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 910 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 911 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 912 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 913 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 914 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 915 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 916 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 917 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 918 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 919 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 920 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 921 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 922 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 923 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 924 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 925 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 926 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 927 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 928 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 929 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 930 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 931 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 932 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 933 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 934 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 935 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 936 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 937 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 938 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 939 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 940 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 941 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 942 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 943 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 944 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 945 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 946 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 947 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 948 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 949 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 950 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 951 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 952 0x2d02ef8d 953 }; 954 const unsigned char *end; 955 956 crc = ~crc & 0xffffffff; 957 for (end = buf + len; buf < end; ++ buf) 958 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8); 959 return ~crc & 0xffffffff;; 960} 961 962 963/* 964INTERNAL_FUNCTION 965 get_debug_link_info 966 967SYNOPSIS 968 char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out); 969 970DESCRIPTION 971 fetch the filename and CRC32 value for any separate debuginfo 972 associated with @var{abfd}. Return NULL if no such info found, 973 otherwise return filename and update @var{crc32_out}. 974*/ 975 976static char * 977get_debug_link_info (bfd *abfd, unsigned long *crc32_out) 978{ 979 asection *sect; 980 unsigned long crc32; 981 bfd_byte *contents; 982 int crc_offset; 983 984 BFD_ASSERT (abfd); 985 BFD_ASSERT (crc32_out); 986 987 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK); 988 989 if (sect == NULL) 990 return NULL; 991 992 if (!bfd_malloc_and_get_section (abfd, sect, &contents)) 993 { 994 if (contents != NULL) 995 free (contents); 996 return NULL; 997 } 998 999 /* Crc value is stored after the filename, aligned up to 4 bytes. */ 1000 crc_offset = strlen (contents) + 1; 1001 crc_offset = (crc_offset + 3) & ~3; 1002 1003 crc32 = bfd_get_32 (abfd, contents + crc_offset); 1004 1005 *crc32_out = crc32; 1006 return contents; 1007} 1008 1009/* 1010INTERNAL_FUNCTION 1011 separate_debug_file_exists 1012 1013SYNOPSIS 1014 bfd_boolean separate_debug_file_exists 1015 (char *name, unsigned long crc32); 1016 1017DESCRIPTION 1018 Checks to see if @var{name} is a file and if its contents 1019 match @var{crc32}. 1020*/ 1021 1022static bfd_boolean 1023separate_debug_file_exists (const char *name, const unsigned long crc) 1024{ 1025 static char buffer [8 * 1024]; 1026 unsigned long file_crc = 0; 1027 int fd; 1028 bfd_size_type count; 1029 1030 BFD_ASSERT (name); 1031 1032 fd = open (name, O_RDONLY); 1033 if (fd < 0) 1034 return FALSE; 1035 1036 while ((count = read (fd, buffer, sizeof (buffer))) > 0) 1037 file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count); 1038 1039 close (fd); 1040 1041 return crc == file_crc; 1042} 1043 1044 1045/* 1046INTERNAL_FUNCTION 1047 find_separate_debug_file 1048 1049SYNOPSIS 1050 char *find_separate_debug_file (bfd *abfd); 1051 1052DESCRIPTION 1053 Searches @var{abfd} for a reference to separate debugging 1054 information, scans various locations in the filesystem, including 1055 the file tree rooted at @var{debug_file_directory}, and returns a 1056 filename of such debugging information if the file is found and has 1057 matching CRC32. Returns NULL if no reference to debugging file 1058 exists, or file cannot be found. 1059*/ 1060 1061static char * 1062find_separate_debug_file (bfd *abfd, const char *debug_file_directory) 1063{ 1064 char *basename; 1065 char *dir; 1066 char *debugfile; 1067 unsigned long crc32; 1068 int i; 1069 1070 BFD_ASSERT (abfd); 1071 if (debug_file_directory == NULL) 1072 debug_file_directory = "."; 1073 1074 /* BFD may have been opened from a stream. */ 1075 if (! abfd->filename) 1076 return NULL; 1077 1078 basename = get_debug_link_info (abfd, & crc32); 1079 if (basename == NULL) 1080 return NULL; 1081 1082 if (strlen (basename) < 1) 1083 { 1084 free (basename); 1085 return NULL; 1086 } 1087 1088 dir = strdup (abfd->filename); 1089 if (dir == NULL) 1090 { 1091 free (basename); 1092 return NULL; 1093 } 1094 BFD_ASSERT (strlen (dir) != 0); 1095 1096 /* Strip off filename part. */ 1097 for (i = strlen (dir) - 1; i >= 0; i--) 1098 if (IS_DIR_SEPARATOR (dir[i])) 1099 break; 1100 1101 dir[i + 1] = '\0'; 1102 BFD_ASSERT (dir[i] == '/' || dir[0] == '\0'); 1103 1104 debugfile = malloc (strlen (debug_file_directory) + 1 1105 + strlen (dir) 1106 + strlen (".debug/") 1107 + strlen (basename) 1108 + 1); 1109 if (debugfile == NULL) 1110 { 1111 free (basename); 1112 free (dir); 1113 return NULL; 1114 } 1115 1116 /* First try in the same directory as the original file: */ 1117 strcpy (debugfile, dir); 1118 strcat (debugfile, basename); 1119 1120 if (separate_debug_file_exists (debugfile, crc32)) 1121 { 1122 free (basename); 1123 free (dir); 1124 return debugfile; 1125 } 1126 1127 /* Then try in a subdirectory called .debug. */ 1128 strcpy (debugfile, dir); 1129 strcat (debugfile, ".debug/"); 1130 strcat (debugfile, basename); 1131 1132 if (separate_debug_file_exists (debugfile, crc32)) 1133 { 1134 free (basename); 1135 free (dir); 1136 return debugfile; 1137 } 1138 1139 /* Then try in the global debugfile directory. */ 1140 strcpy (debugfile, debug_file_directory); 1141 i = strlen (debug_file_directory) - 1; 1142 if (i > 0 1143 && debug_file_directory[i] != '/' 1144 && dir[0] != '/') 1145 strcat (debugfile, "/"); 1146 strcat (debugfile, dir); 1147 strcat (debugfile, basename); 1148 1149 if (separate_debug_file_exists (debugfile, crc32)) 1150 { 1151 free (basename); 1152 free (dir); 1153 return debugfile; 1154 } 1155 1156 free (debugfile); 1157 free (basename); 1158 free (dir); 1159 return NULL; 1160} 1161 1162 1163/* 1164FUNCTION 1165 bfd_follow_gnu_debuglink 1166 1167SYNOPSIS 1168 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir); 1169 1170DESCRIPTION 1171 1172 Takes a BFD and searches it for a .gnu_debuglink section. If this 1173 section is found, it examines the section for the name and checksum 1174 of a '.debug' file containing auxiliary debugging information. It 1175 then searches the filesystem for this .debug file in some standard 1176 locations, including the directory tree rooted at @var{dir}, and if 1177 found returns the full filename. 1178 1179 If @var{dir} is NULL, it will search a default path configured into 1180 libbfd at build time. [XXX this feature is not currently 1181 implemented]. 1182 1183RETURNS 1184 <<NULL>> on any errors or failure to locate the .debug file, 1185 otherwise a pointer to a heap-allocated string containing the 1186 filename. The caller is responsible for freeing this string. 1187*/ 1188 1189char * 1190bfd_follow_gnu_debuglink (bfd *abfd, const char *dir) 1191{ 1192#if 0 /* Disabled until DEBUGDIR can be defined by configure.in. */ 1193 if (dir == NULL) 1194 dir = DEBUGDIR; 1195#endif 1196 return find_separate_debug_file (abfd, dir); 1197} 1198 1199/* 1200FUNCTION 1201 bfd_create_gnu_debuglink_section 1202 1203SYNOPSIS 1204 struct bfd_section *bfd_create_gnu_debuglink_section 1205 (bfd *abfd, const char *filename); 1206 1207DESCRIPTION 1208 1209 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The section is sized 1210 to be big enough to contain a link to the specified @var{filename}. 1211 1212RETURNS 1213 A pointer to the new section is returned if all is ok. Otherwise <<NULL>> is 1214 returned and bfd_error is set. 1215*/ 1216 1217asection * 1218bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename) 1219{ 1220 asection *sect; 1221 bfd_size_type debuglink_size; 1222 1223 if (abfd == NULL || filename == NULL) 1224 { 1225 bfd_set_error (bfd_error_invalid_operation); 1226 return NULL; 1227 } 1228 1229 /* Strip off any path components in filename. */ 1230 filename = lbasename (filename); 1231 1232 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK); 1233 if (sect) 1234 { 1235 /* Section already exists. */ 1236 bfd_set_error (bfd_error_invalid_operation); 1237 return NULL; 1238 } 1239 1240 sect = bfd_make_section (abfd, GNU_DEBUGLINK); 1241 if (sect == NULL) 1242 return NULL; 1243 1244 if (! bfd_set_section_flags (abfd, sect, 1245 SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING)) 1246 /* XXX Should we delete the section from the bfd ? */ 1247 return NULL; 1248 1249 1250 debuglink_size = strlen (filename) + 1; 1251 debuglink_size += 3; 1252 debuglink_size &= ~3; 1253 debuglink_size += 4; 1254 1255 if (! bfd_set_section_size (abfd, sect, debuglink_size)) 1256 /* XXX Should we delete the section from the bfd ? */ 1257 return NULL; 1258 1259 return sect; 1260} 1261 1262 1263/* 1264FUNCTION 1265 bfd_fill_in_gnu_debuglink_section 1266 1267SYNOPSIS 1268 bfd_boolean bfd_fill_in_gnu_debuglink_section 1269 (bfd *abfd, struct bfd_section *sect, const char *filename); 1270 1271DESCRIPTION 1272 1273 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT} 1274 and fills in the contents of the section to contain a link to the 1275 specified @var{filename}. The filename should be relative to the 1276 current directory. 1277 1278RETURNS 1279 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned 1280 and bfd_error is set. 1281*/ 1282 1283bfd_boolean 1284bfd_fill_in_gnu_debuglink_section (bfd *abfd, 1285 struct bfd_section *sect, 1286 const char *filename) 1287{ 1288 bfd_size_type debuglink_size; 1289 unsigned long crc32; 1290 char * contents; 1291 bfd_size_type crc_offset; 1292 FILE * handle; 1293 static char buffer[8 * 1024]; 1294 size_t count; 1295 1296 if (abfd == NULL || sect == NULL || filename == NULL) 1297 { 1298 bfd_set_error (bfd_error_invalid_operation); 1299 return FALSE; 1300 } 1301 1302 /* Make sure that we can read the file. 1303 XXX - Should we attempt to locate the debug info file using the same 1304 algorithm as gdb ? At the moment, since we are creating the 1305 .gnu_debuglink section, we insist upon the user providing us with a 1306 correct-for-section-creation-time path, but this need not conform to 1307 the gdb location algorithm. */ 1308 handle = fopen (filename, FOPEN_RB); 1309 if (handle == NULL) 1310 { 1311 bfd_set_error (bfd_error_system_call); 1312 return FALSE; 1313 } 1314 1315 crc32 = 0; 1316 while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0) 1317 crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count); 1318 fclose (handle); 1319 1320 /* Strip off any path components in filename, 1321 now that we no longer need them. */ 1322 filename = lbasename (filename); 1323 1324 debuglink_size = strlen (filename) + 1; 1325 debuglink_size += 3; 1326 debuglink_size &= ~3; 1327 debuglink_size += 4; 1328 1329 contents = malloc (debuglink_size); 1330 if (contents == NULL) 1331 { 1332 /* XXX Should we delete the section from the bfd ? */ 1333 bfd_set_error (bfd_error_no_memory); 1334 return FALSE; 1335 } 1336 1337 strcpy (contents, filename); 1338 crc_offset = debuglink_size - 4; 1339 1340 bfd_put_32 (abfd, crc32, contents + crc_offset); 1341 1342 if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size)) 1343 { 1344 /* XXX Should we delete the section from the bfd ? */ 1345 free (contents); 1346 return FALSE; 1347 } 1348 1349 return TRUE; 1350} 1351