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, 2005, 2006, 2007, 2008 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 3 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., 51 Franklin Street - Fifth Floor, Boston, 23 MA 02110-1301, USA. */ 24 25 #include "sysdep.h" 26 #include "bfd.h" 27 #include "objalloc.h" 28 #include "libbfd.h" 29 #include "libiberty.h" 30 31 #ifndef S_IXUSR 32 #define S_IXUSR 0100 /* Execute by owner. */ 33 #endif 34 #ifndef S_IXGRP 35 #define S_IXGRP 0010 /* Execute by group. */ 36 #endif 37 #ifndef S_IXOTH 38 #define S_IXOTH 0001 /* Execute by others. */ 39 #endif 40 41 /* Counter used to initialize the bfd identifier. */ 42 43 static unsigned int _bfd_id_counter = 0; 44 45 /* fdopen is a loser -- we should use stdio exclusively. Unfortunately 46 if we do that we can't use fcntl. */ 47 48 /* Return a new BFD. All BFD's are allocated through this routine. */ 49 50 bfd * 51 _bfd_new_bfd (void) 52 { 53 bfd *nbfd; 54 55 nbfd = bfd_zmalloc (sizeof (bfd)); 56 if (nbfd == NULL) 57 return NULL; 58 59 nbfd->id = _bfd_id_counter++; 60 61 nbfd->memory = objalloc_create (); 62 if (nbfd->memory == NULL) 63 { 64 bfd_set_error (bfd_error_no_memory); 65 free (nbfd); 66 return NULL; 67 } 68 69 nbfd->arch_info = &bfd_default_arch_struct; 70 71 nbfd->direction = no_direction; 72 nbfd->iostream = NULL; 73 nbfd->where = 0; 74 if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc, 75 sizeof (struct section_hash_entry), 251)) 76 { 77 free (nbfd); 78 return NULL; 79 } 80 nbfd->sections = NULL; 81 nbfd->section_last = NULL; 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->iovec = obfd->iovec; 108 nbfd->my_archive = obfd; 109 nbfd->direction = read_direction; 110 nbfd->target_defaulted = obfd->target_defaulted; 111 return nbfd; 112 } 113 114 /* Delete a BFD. */ 115 116 void 117 _bfd_delete_bfd (bfd *abfd) 118 { 119 if (abfd->memory) 120 { 121 bfd_hash_table_free (&abfd->section_htab); 122 objalloc_free ((struct objalloc *) abfd->memory); 123 } 124 free (abfd); 125 } 126 127 /* Free objalloc memory. */ 128 129 bfd_boolean 130 _bfd_free_cached_info (bfd *abfd) 131 { 132 if (abfd->memory) 133 { 134 bfd_hash_table_free (&abfd->section_htab); 135 objalloc_free ((struct objalloc *) abfd->memory); 136 137 abfd->sections = NULL; 138 abfd->section_last = NULL; 139 abfd->outsymbols = NULL; 140 abfd->tdata.any = NULL; 141 abfd->usrdata = NULL; 142 abfd->memory = NULL; 143 } 144 145 return TRUE; 146 } 147 148 /* 149 SECTION 150 Opening and closing BFDs 151 152 SUBSECTION 153 Functions for opening and closing 154 */ 155 156 /* 157 FUNCTION 158 bfd_fopen 159 160 SYNOPSIS 161 bfd *bfd_fopen (const char *filename, const char *target, 162 const char *mode, int fd); 163 164 DESCRIPTION 165 Open the file @var{filename} with the target @var{target}. 166 Return a pointer to the created BFD. If @var{fd} is not -1, 167 then <<fdopen>> is used to open the file; otherwise, <<fopen>> 168 is used. @var{mode} is passed directly to <<fopen>> or 169 <<fdopen>>. 170 171 Calls <<bfd_find_target>>, so @var{target} is interpreted as by 172 that function. 173 174 The new BFD is marked as cacheable iff @var{fd} is -1. 175 176 If <<NULL>> is returned then an error has occured. Possible errors 177 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or 178 <<system_call>> error. 179 */ 180 181 bfd * 182 bfd_fopen (const char *filename, const char *target, const char *mode, int fd) 183 { 184 bfd *nbfd; 185 const bfd_target *target_vec; 186 187 nbfd = _bfd_new_bfd (); 188 if (nbfd == NULL) 189 return NULL; 190 191 target_vec = bfd_find_target (target, nbfd); 192 if (target_vec == NULL) 193 { 194 _bfd_delete_bfd (nbfd); 195 return NULL; 196 } 197 198 #ifdef HAVE_FDOPEN 199 if (fd != -1) 200 nbfd->iostream = fdopen (fd, mode); 201 else 202 #endif 203 nbfd->iostream = real_fopen (filename, mode); 204 if (nbfd->iostream == NULL) 205 { 206 bfd_set_error (bfd_error_system_call); 207 _bfd_delete_bfd (nbfd); 208 return NULL; 209 } 210 211 /* OK, put everything where it belongs. */ 212 nbfd->filename = filename; 213 214 /* Figure out whether the user is opening the file for reading, 215 writing, or both, by looking at the MODE argument. */ 216 if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a') 217 && mode[1] == '+') 218 nbfd->direction = both_direction; 219 else if (mode[0] == 'r') 220 nbfd->direction = read_direction; 221 else 222 nbfd->direction = write_direction; 223 224 if (! bfd_cache_init (nbfd)) 225 { 226 _bfd_delete_bfd (nbfd); 227 return NULL; 228 } 229 nbfd->opened_once = TRUE; 230 /* If we opened the file by name, mark it cacheable; we can close it 231 and reopen it later. However, if a file descriptor was provided, 232 then it may have been opened with special flags that make it 233 unsafe to close and reopen the file. */ 234 if (fd == -1) 235 bfd_set_cacheable (nbfd, TRUE); 236 237 return nbfd; 238 } 239 240 /* 241 FUNCTION 242 bfd_openr 243 244 SYNOPSIS 245 bfd *bfd_openr (const char *filename, const char *target); 246 247 DESCRIPTION 248 Open the file @var{filename} (using <<fopen>>) with the target 249 @var{target}. Return a pointer to the created BFD. 250 251 Calls <<bfd_find_target>>, so @var{target} is interpreted as by 252 that function. 253 254 If <<NULL>> is returned then an error has occured. Possible errors 255 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or 256 <<system_call>> error. 257 */ 258 259 bfd * 260 bfd_openr (const char *filename, const char *target) 261 { 262 return bfd_fopen (filename, target, FOPEN_RB, -1); 263 } 264 265 /* Don't try to `optimize' this function: 266 267 o - We lock using stack space so that interrupting the locking 268 won't cause a storage leak. 269 o - We open the file stream last, since we don't want to have to 270 close it if anything goes wrong. Closing the stream means closing 271 the file descriptor too, even though we didn't open it. */ 272 /* 273 FUNCTION 274 bfd_fdopenr 275 276 SYNOPSIS 277 bfd *bfd_fdopenr (const char *filename, const char *target, int fd); 278 279 DESCRIPTION 280 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to 281 <<fopen>>. It opens a BFD on a file already described by the 282 @var{fd} supplied. 283 284 When the file is later <<bfd_close>>d, the file descriptor will 285 be closed. If the caller desires that this file descriptor be 286 cached by BFD (opened as needed, closed as needed to free 287 descriptors for other opens), with the supplied @var{fd} used as 288 an initial file descriptor (but subject to closure at any time), 289 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default 290 is to assume no caching; the file descriptor will remain open 291 until <<bfd_close>>, and will not be affected by BFD operations 292 on other files. 293 294 Possible errors are <<bfd_error_no_memory>>, 295 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>. 296 */ 297 298 bfd * 299 bfd_fdopenr (const char *filename, const char *target, int fd) 300 { 301 const char *mode; 302 #if defined(HAVE_FCNTL) && defined(F_GETFL) 303 int fdflags; 304 #endif 305 306 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL) 307 mode = FOPEN_RUB; /* Assume full access. */ 308 #else 309 fdflags = fcntl (fd, F_GETFL, NULL); 310 if (fdflags == -1) 311 { 312 bfd_set_error (bfd_error_system_call); 313 return NULL; 314 } 315 316 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */ 317 switch (fdflags & (O_ACCMODE)) 318 { 319 case O_RDONLY: mode = FOPEN_RB; break; 320 case O_WRONLY: mode = FOPEN_RUB; break; 321 case O_RDWR: mode = FOPEN_RUB; break; 322 default: abort (); 323 } 324 #endif 325 326 return bfd_fopen (filename, target, mode, fd); 327 } 328 329 /* 330 FUNCTION 331 bfd_openstreamr 332 333 SYNOPSIS 334 bfd *bfd_openstreamr (const char *, const char *, void *); 335 336 DESCRIPTION 337 338 Open a BFD for read access on an existing stdio stream. When 339 the BFD is passed to <<bfd_close>>, the stream will be closed. 340 */ 341 342 bfd * 343 bfd_openstreamr (const char *filename, const char *target, void *streamarg) 344 { 345 FILE *stream = streamarg; 346 bfd *nbfd; 347 const bfd_target *target_vec; 348 349 nbfd = _bfd_new_bfd (); 350 if (nbfd == NULL) 351 return NULL; 352 353 target_vec = bfd_find_target (target, nbfd); 354 if (target_vec == NULL) 355 { 356 _bfd_delete_bfd (nbfd); 357 return NULL; 358 } 359 360 nbfd->iostream = stream; 361 nbfd->filename = filename; 362 nbfd->direction = read_direction; 363 364 if (! bfd_cache_init (nbfd)) 365 { 366 _bfd_delete_bfd (nbfd); 367 return NULL; 368 } 369 370 return nbfd; 371 } 372 373 /* 374 FUNCTION 375 bfd_openr_iovec 376 377 SYNOPSIS 378 bfd *bfd_openr_iovec (const char *filename, const char *target, 379 void *(*open) (struct bfd *nbfd, 380 void *open_closure), 381 void *open_closure, 382 file_ptr (*pread) (struct bfd *nbfd, 383 void *stream, 384 void *buf, 385 file_ptr nbytes, 386 file_ptr offset), 387 int (*close) (struct bfd *nbfd, 388 void *stream), 389 int (*stat) (struct bfd *abfd, 390 void *stream, 391 struct stat *sb)); 392 393 DESCRIPTION 394 395 Create and return a BFD backed by a read-only @var{stream}. 396 The @var{stream} is created using @var{open}, accessed using 397 @var{pread} and destroyed using @var{close}. 398 399 Calls <<bfd_find_target>>, so @var{target} is interpreted as by 400 that function. 401 402 Calls @var{open} (which can call <<bfd_zalloc>> and 403 <<bfd_get_filename>>) to obtain the read-only stream backing 404 the BFD. @var{open} either succeeds returning the 405 non-<<NULL>> @var{stream}, or fails returning <<NULL>> 406 (setting <<bfd_error>>). 407 408 Calls @var{pread} to request @var{nbytes} of data from 409 @var{stream} starting at @var{offset} (e.g., via a call to 410 <<bfd_read>>). @var{pread} either succeeds returning the 411 number of bytes read (which can be less than @var{nbytes} when 412 end-of-file), or fails returning -1 (setting <<bfd_error>>). 413 414 Calls @var{close} when the BFD is later closed using 415 <<bfd_close>>. @var{close} either succeeds returning 0, or 416 fails returning -1 (setting <<bfd_error>>). 417 418 Calls @var{stat} to fill in a stat structure for bfd_stat, 419 bfd_get_size, and bfd_get_mtime calls. @var{stat} returns 0 420 on success, or returns -1 on failure (setting <<bfd_error>>). 421 422 If <<bfd_openr_iovec>> returns <<NULL>> then an error has 423 occurred. Possible errors are <<bfd_error_no_memory>>, 424 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>. 425 426 */ 427 428 struct opncls 429 { 430 void *stream; 431 file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf, 432 file_ptr nbytes, file_ptr offset); 433 int (*close) (struct bfd *abfd, void *stream); 434 int (*stat) (struct bfd *abfd, void *stream, struct stat *sb); 435 file_ptr where; 436 }; 437 438 static file_ptr 439 opncls_btell (struct bfd *abfd) 440 { 441 struct opncls *vec = abfd->iostream; 442 return vec->where; 443 } 444 445 static int 446 opncls_bseek (struct bfd *abfd, file_ptr offset, int whence) 447 { 448 struct opncls *vec = abfd->iostream; 449 switch (whence) 450 { 451 case SEEK_SET: vec->where = offset; break; 452 case SEEK_CUR: vec->where += offset; break; 453 case SEEK_END: return -1; 454 } 455 return 0; 456 } 457 458 static file_ptr 459 opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes) 460 { 461 struct opncls *vec = abfd->iostream; 462 file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where); 463 if (nread < 0) 464 return nread; 465 vec->where += nread; 466 return nread; 467 } 468 469 static file_ptr 470 opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED, 471 const void *where ATTRIBUTE_UNUSED, 472 file_ptr nbytes ATTRIBUTE_UNUSED) 473 { 474 return -1; 475 } 476 477 static int 478 opncls_bclose (struct bfd *abfd) 479 { 480 struct opncls *vec = abfd->iostream; 481 /* Since the VEC's memory is bound to the bfd deleting the bfd will 482 free it. */ 483 int status = 0; 484 if (vec->close != NULL) 485 status = (vec->close) (abfd, vec->stream); 486 abfd->iostream = NULL; 487 return status; 488 } 489 490 static int 491 opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED) 492 { 493 return 0; 494 } 495 496 static int 497 opncls_bstat (struct bfd *abfd, struct stat *sb) 498 { 499 struct opncls *vec = abfd->iostream; 500 501 memset (sb, 0, sizeof (*sb)); 502 if (vec->stat == NULL) 503 return 0; 504 505 return (vec->stat) (abfd, vec->stream, sb); 506 } 507 508 static const struct bfd_iovec opncls_iovec = { 509 &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek, 510 &opncls_bclose, &opncls_bflush, &opncls_bstat 511 }; 512 513 bfd * 514 bfd_openr_iovec (const char *filename, const char *target, 515 void *(*open) (struct bfd *nbfd, 516 void *open_closure), 517 void *open_closure, 518 file_ptr (*pread) (struct bfd *abfd, 519 void *stream, 520 void *buf, 521 file_ptr nbytes, 522 file_ptr offset), 523 int (*close) (struct bfd *nbfd, 524 void *stream), 525 int (*stat) (struct bfd *abfd, 526 void *stream, 527 struct stat *sb)) 528 { 529 bfd *nbfd; 530 const bfd_target *target_vec; 531 struct opncls *vec; 532 void *stream; 533 534 nbfd = _bfd_new_bfd (); 535 if (nbfd == NULL) 536 return NULL; 537 538 target_vec = bfd_find_target (target, nbfd); 539 if (target_vec == NULL) 540 { 541 _bfd_delete_bfd (nbfd); 542 return NULL; 543 } 544 545 nbfd->filename = filename; 546 nbfd->direction = read_direction; 547 548 /* `open (...)' would get expanded by an the open(2) syscall macro. */ 549 stream = (*open) (nbfd, open_closure); 550 if (stream == NULL) 551 { 552 _bfd_delete_bfd (nbfd); 553 return NULL; 554 } 555 556 vec = bfd_zalloc (nbfd, sizeof (struct opncls)); 557 vec->stream = stream; 558 vec->pread = pread; 559 vec->close = close; 560 vec->stat = stat; 561 562 nbfd->iovec = &opncls_iovec; 563 nbfd->iostream = vec; 564 565 return nbfd; 566 } 567 568 /* bfd_openw -- open for writing. 569 Returns a pointer to a freshly-allocated BFD on success, or NULL. 570 571 See comment by bfd_fdopenr before you try to modify this function. */ 572 573 /* 574 FUNCTION 575 bfd_openw 576 577 SYNOPSIS 578 bfd *bfd_openw (const char *filename, const char *target); 579 580 DESCRIPTION 581 Create a BFD, associated with file @var{filename}, using the 582 file format @var{target}, and return a pointer to it. 583 584 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>, 585 <<bfd_error_invalid_target>>. 586 */ 587 588 bfd * 589 bfd_openw (const char *filename, const char *target) 590 { 591 bfd *nbfd; 592 const bfd_target *target_vec; 593 594 /* nbfd has to point to head of malloc'ed block so that bfd_close may 595 reclaim it correctly. */ 596 nbfd = _bfd_new_bfd (); 597 if (nbfd == NULL) 598 return NULL; 599 600 target_vec = bfd_find_target (target, nbfd); 601 if (target_vec == NULL) 602 { 603 _bfd_delete_bfd (nbfd); 604 return NULL; 605 } 606 607 nbfd->filename = filename; 608 nbfd->direction = write_direction; 609 610 if (bfd_open_file (nbfd) == NULL) 611 { 612 /* File not writeable, etc. */ 613 bfd_set_error (bfd_error_system_call); 614 _bfd_delete_bfd (nbfd); 615 return NULL; 616 } 617 618 return nbfd; 619 } 620 621 /* 622 623 FUNCTION 624 bfd_close 625 626 SYNOPSIS 627 bfd_boolean bfd_close (bfd *abfd); 628 629 DESCRIPTION 630 631 Close a BFD. If the BFD was open for writing, then pending 632 operations are completed and the file written out and closed. 633 If the created file is executable, then <<chmod>> is called 634 to mark it as such. 635 636 All memory attached to the BFD is released. 637 638 The file descriptor associated with the BFD is closed (even 639 if it was passed in to BFD by <<bfd_fdopenr>>). 640 641 RETURNS 642 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. 643 */ 644 645 646 bfd_boolean 647 bfd_close (bfd *abfd) 648 { 649 bfd_boolean ret; 650 bfd *nbfd; 651 bfd *next; 652 653 if (bfd_write_p (abfd)) 654 { 655 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) 656 return FALSE; 657 } 658 659 /* Close nested archives (if this bfd is a thin archive). */ 660 for (nbfd = abfd->nested_archives; nbfd; nbfd = next) 661 { 662 next = nbfd->archive_next; 663 bfd_close (nbfd); 664 } 665 666 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) 667 return FALSE; 668 669 /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io 670 vector. */ 671 if (!(abfd->flags & BFD_IN_MEMORY)) 672 ret = abfd->iovec->bclose (abfd); 673 else 674 ret = TRUE; 675 676 /* If the file was open for writing and is now executable, 677 make it so. */ 678 if (ret 679 && abfd->direction == write_direction 680 && abfd->flags & EXEC_P) 681 { 682 struct stat buf; 683 684 if (stat (abfd->filename, &buf) == 0) 685 { 686 unsigned int mask = umask (0); 687 688 umask (mask); 689 chmod (abfd->filename, 690 (0777 691 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); 692 } 693 } 694 695 _bfd_delete_bfd (abfd); 696 697 return ret; 698 } 699 700 /* 701 FUNCTION 702 bfd_close_all_done 703 704 SYNOPSIS 705 bfd_boolean bfd_close_all_done (bfd *); 706 707 DESCRIPTION 708 Close a BFD. Differs from <<bfd_close>> since it does not 709 complete any pending operations. This routine would be used 710 if the application had just used BFD for swapping and didn't 711 want to use any of the writing code. 712 713 If the created file is executable, then <<chmod>> is called 714 to mark it as such. 715 716 All memory attached to the BFD is released. 717 718 RETURNS 719 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. 720 */ 721 722 bfd_boolean 723 bfd_close_all_done (bfd *abfd) 724 { 725 bfd_boolean ret; 726 727 ret = bfd_cache_close (abfd); 728 729 /* If the file was open for writing and is now executable, 730 make it so. */ 731 if (ret 732 && abfd->direction == write_direction 733 && abfd->flags & EXEC_P) 734 { 735 struct stat buf; 736 737 if (stat (abfd->filename, &buf) == 0) 738 { 739 unsigned int mask = umask (0); 740 741 umask (mask); 742 chmod (abfd->filename, 743 (0777 744 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); 745 } 746 } 747 748 _bfd_delete_bfd (abfd); 749 750 return ret; 751 } 752 753 /* 754 FUNCTION 755 bfd_create 756 757 SYNOPSIS 758 bfd *bfd_create (const char *filename, bfd *templ); 759 760 DESCRIPTION 761 Create a new BFD in the manner of <<bfd_openw>>, but without 762 opening a file. The new BFD takes the target from the target 763 used by @var{template}. The format is always set to <<bfd_object>>. 764 */ 765 766 bfd * 767 bfd_create (const char *filename, bfd *templ) 768 { 769 bfd *nbfd; 770 771 nbfd = _bfd_new_bfd (); 772 if (nbfd == NULL) 773 return NULL; 774 nbfd->filename = filename; 775 if (templ) 776 nbfd->xvec = templ->xvec; 777 nbfd->direction = no_direction; 778 bfd_set_format (nbfd, bfd_object); 779 780 return nbfd; 781 } 782 783 /* 784 FUNCTION 785 bfd_make_writable 786 787 SYNOPSIS 788 bfd_boolean bfd_make_writable (bfd *abfd); 789 790 DESCRIPTION 791 Takes a BFD as created by <<bfd_create>> and converts it 792 into one like as returned by <<bfd_openw>>. It does this 793 by converting the BFD to BFD_IN_MEMORY. It's assumed that 794 you will call <<bfd_make_readable>> on this bfd later. 795 796 RETURNS 797 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. 798 */ 799 800 bfd_boolean 801 bfd_make_writable (bfd *abfd) 802 { 803 struct bfd_in_memory *bim; 804 805 if (abfd->direction != no_direction) 806 { 807 bfd_set_error (bfd_error_invalid_operation); 808 return FALSE; 809 } 810 811 bim = bfd_malloc (sizeof (struct bfd_in_memory)); 812 if (bim == NULL) 813 return FALSE; /* bfd_error already set. */ 814 abfd->iostream = bim; 815 /* bfd_bwrite will grow these as needed. */ 816 bim->size = 0; 817 bim->buffer = 0; 818 819 abfd->flags |= BFD_IN_MEMORY; 820 abfd->direction = write_direction; 821 abfd->where = 0; 822 823 return TRUE; 824 } 825 826 /* 827 FUNCTION 828 bfd_make_readable 829 830 SYNOPSIS 831 bfd_boolean bfd_make_readable (bfd *abfd); 832 833 DESCRIPTION 834 Takes a BFD as created by <<bfd_create>> and 835 <<bfd_make_writable>> and converts it into one like as 836 returned by <<bfd_openr>>. It does this by writing the 837 contents out to the memory buffer, then reversing the 838 direction. 839 840 RETURNS 841 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */ 842 843 bfd_boolean 844 bfd_make_readable (bfd *abfd) 845 { 846 if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY)) 847 { 848 bfd_set_error (bfd_error_invalid_operation); 849 return FALSE; 850 } 851 852 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) 853 return FALSE; 854 855 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) 856 return FALSE; 857 858 859 abfd->arch_info = &bfd_default_arch_struct; 860 861 abfd->where = 0; 862 abfd->format = bfd_unknown; 863 abfd->my_archive = NULL; 864 abfd->origin = 0; 865 abfd->opened_once = FALSE; 866 abfd->output_has_begun = FALSE; 867 abfd->section_count = 0; 868 abfd->usrdata = NULL; 869 abfd->cacheable = FALSE; 870 abfd->flags = BFD_IN_MEMORY; 871 abfd->mtime_set = FALSE; 872 873 abfd->target_defaulted = TRUE; 874 abfd->direction = read_direction; 875 abfd->sections = 0; 876 abfd->symcount = 0; 877 abfd->outsymbols = 0; 878 abfd->tdata.any = 0; 879 880 bfd_section_list_clear (abfd); 881 bfd_check_format (abfd, bfd_object); 882 883 return TRUE; 884 } 885 886 /* 887 INTERNAL_FUNCTION 888 bfd_alloc 889 890 SYNOPSIS 891 void *bfd_alloc (bfd *abfd, bfd_size_type wanted); 892 893 DESCRIPTION 894 Allocate a block of @var{wanted} bytes of memory attached to 895 <<abfd>> and return a pointer to it. 896 */ 897 898 void * 899 bfd_alloc (bfd *abfd, bfd_size_type size) 900 { 901 void *ret; 902 903 if (size != (unsigned long) size) 904 { 905 bfd_set_error (bfd_error_no_memory); 906 return NULL; 907 } 908 909 ret = objalloc_alloc (abfd->memory, (unsigned long) size); 910 if (ret == NULL) 911 bfd_set_error (bfd_error_no_memory); 912 return ret; 913 } 914 915 /* 916 INTERNAL_FUNCTION 917 bfd_alloc2 918 919 SYNOPSIS 920 void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size); 921 922 DESCRIPTION 923 Allocate a block of @var{nmemb} elements of @var{size} bytes each 924 of memory attached to <<abfd>> and return a pointer to it. 925 */ 926 927 void * 928 bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size) 929 { 930 void *ret; 931 932 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE 933 && size != 0 934 && nmemb > ~(bfd_size_type) 0 / size) 935 { 936 bfd_set_error (bfd_error_no_memory); 937 return NULL; 938 } 939 940 size *= nmemb; 941 942 if (size != (unsigned long) size) 943 { 944 bfd_set_error (bfd_error_no_memory); 945 return NULL; 946 } 947 948 ret = objalloc_alloc (abfd->memory, (unsigned long) size); 949 if (ret == NULL) 950 bfd_set_error (bfd_error_no_memory); 951 return ret; 952 } 953 954 /* 955 INTERNAL_FUNCTION 956 bfd_zalloc 957 958 SYNOPSIS 959 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted); 960 961 DESCRIPTION 962 Allocate a block of @var{wanted} bytes of zeroed memory 963 attached to <<abfd>> and return a pointer to it. 964 */ 965 966 void * 967 bfd_zalloc (bfd *abfd, bfd_size_type size) 968 { 969 void *res; 970 971 res = bfd_alloc (abfd, size); 972 if (res) 973 memset (res, 0, (size_t) size); 974 return res; 975 } 976 977 /* 978 INTERNAL_FUNCTION 979 bfd_zalloc2 980 981 SYNOPSIS 982 void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size); 983 984 DESCRIPTION 985 Allocate a block of @var{nmemb} elements of @var{size} bytes each 986 of zeroed memory attached to <<abfd>> and return a pointer to it. 987 */ 988 989 void * 990 bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size) 991 { 992 void *res; 993 994 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE 995 && size != 0 996 && nmemb > ~(bfd_size_type) 0 / size) 997 { 998 bfd_set_error (bfd_error_no_memory); 999 return NULL; 1000 } 1001 1002 size *= nmemb; 1003 1004 res = bfd_alloc (abfd, size); 1005 if (res) 1006 memset (res, 0, (size_t) size); 1007 return res; 1008 } 1009 1010 /* Free a block allocated for a BFD. 1011 Note: Also frees all more recently allocated blocks! */ 1012 1013 void 1014 bfd_release (bfd *abfd, void *block) 1015 { 1016 objalloc_free_block ((struct objalloc *) abfd->memory, block); 1017 } 1018 1019 1020 /* 1021 GNU Extension: separate debug-info files 1022 1023 The idea here is that a special section called .gnu_debuglink might be 1024 embedded in a binary file, which indicates that some *other* file 1025 contains the real debugging information. This special section contains a 1026 filename and CRC32 checksum, which we read and resolve to another file, 1027 if it exists. 1028 1029 This facilitates "optional" provision of debugging information, without 1030 having to provide two complete copies of every binary object (with and 1031 without debug symbols). 1032 */ 1033 1034 #define GNU_DEBUGLINK ".gnu_debuglink" 1035 /* 1036 FUNCTION 1037 bfd_calc_gnu_debuglink_crc32 1038 1039 SYNOPSIS 1040 unsigned long bfd_calc_gnu_debuglink_crc32 1041 (unsigned long crc, const unsigned char *buf, bfd_size_type len); 1042 1043 DESCRIPTION 1044 Computes a CRC value as used in the .gnu_debuglink section. 1045 Advances the previously computed @var{crc} value by computing 1046 and adding in the crc32 for @var{len} bytes of @var{buf}. 1047 1048 RETURNS 1049 Return the updated CRC32 value. 1050 */ 1051 1052 unsigned long 1053 bfd_calc_gnu_debuglink_crc32 (unsigned long crc, 1054 const unsigned char *buf, 1055 bfd_size_type len) 1056 { 1057 static const unsigned long crc32_table[256] = 1058 { 1059 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 1060 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 1061 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 1062 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 1063 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 1064 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 1065 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 1066 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 1067 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 1068 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 1069 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 1070 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 1071 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 1072 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 1073 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 1074 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 1075 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 1076 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 1077 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 1078 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 1079 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 1080 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 1081 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 1082 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 1083 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 1084 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 1085 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 1086 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 1087 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 1088 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 1089 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 1090 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 1091 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 1092 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 1093 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 1094 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 1095 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 1096 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 1097 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 1098 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 1099 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 1100 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 1101 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 1102 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 1103 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 1104 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 1105 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 1106 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 1107 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 1108 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 1109 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 1110 0x2d02ef8d 1111 }; 1112 const unsigned char *end; 1113 1114 crc = ~crc & 0xffffffff; 1115 for (end = buf + len; buf < end; ++ buf) 1116 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8); 1117 return ~crc & 0xffffffff;; 1118 } 1119 1120 1121 /* 1122 INTERNAL_FUNCTION 1123 get_debug_link_info 1124 1125 SYNOPSIS 1126 char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out); 1127 1128 DESCRIPTION 1129 fetch the filename and CRC32 value for any separate debuginfo 1130 associated with @var{abfd}. Return NULL if no such info found, 1131 otherwise return filename and update @var{crc32_out}. 1132 */ 1133 1134 static char * 1135 get_debug_link_info (bfd *abfd, unsigned long *crc32_out) 1136 { 1137 asection *sect; 1138 unsigned long crc32; 1139 bfd_byte *contents; 1140 int crc_offset; 1141 char *name; 1142 1143 BFD_ASSERT (abfd); 1144 BFD_ASSERT (crc32_out); 1145 1146 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK); 1147 1148 if (sect == NULL) 1149 return NULL; 1150 1151 if (!bfd_malloc_and_get_section (abfd, sect, &contents)) 1152 { 1153 if (contents != NULL) 1154 free (contents); 1155 return NULL; 1156 } 1157 1158 /* Crc value is stored after the filename, aligned up to 4 bytes. */ 1159 name = (char *) contents; 1160 crc_offset = strlen (name) + 1; 1161 crc_offset = (crc_offset + 3) & ~3; 1162 1163 crc32 = bfd_get_32 (abfd, contents + crc_offset); 1164 1165 *crc32_out = crc32; 1166 return name; 1167 } 1168 1169 /* 1170 INTERNAL_FUNCTION 1171 separate_debug_file_exists 1172 1173 SYNOPSIS 1174 bfd_boolean separate_debug_file_exists 1175 (char *name, unsigned long crc32); 1176 1177 DESCRIPTION 1178 Checks to see if @var{name} is a file and if its contents 1179 match @var{crc32}. 1180 */ 1181 1182 static bfd_boolean 1183 separate_debug_file_exists (const char *name, const unsigned long crc) 1184 { 1185 static unsigned char buffer [8 * 1024]; 1186 unsigned long file_crc = 0; 1187 FILE *f; 1188 bfd_size_type count; 1189 1190 BFD_ASSERT (name); 1191 1192 f = real_fopen (name, FOPEN_RB); 1193 if (f == NULL) 1194 return FALSE; 1195 1196 while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0) 1197 file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count); 1198 1199 fclose (f); 1200 1201 return crc == file_crc; 1202 } 1203 1204 1205 /* 1206 INTERNAL_FUNCTION 1207 find_separate_debug_file 1208 1209 SYNOPSIS 1210 char *find_separate_debug_file (bfd *abfd); 1211 1212 DESCRIPTION 1213 Searches @var{abfd} for a reference to separate debugging 1214 information, scans various locations in the filesystem, including 1215 the file tree rooted at @var{debug_file_directory}, and returns a 1216 filename of such debugging information if the file is found and has 1217 matching CRC32. Returns NULL if no reference to debugging file 1218 exists, or file cannot be found. 1219 */ 1220 1221 static char * 1222 find_separate_debug_file (bfd *abfd, const char *debug_file_directory) 1223 { 1224 char *basename; 1225 char *dir; 1226 char *debugfile; 1227 char *canon_dir; 1228 unsigned long crc32; 1229 size_t dirlen; 1230 size_t canon_dirlen; 1231 1232 BFD_ASSERT (abfd); 1233 if (debug_file_directory == NULL) 1234 debug_file_directory = "."; 1235 1236 /* BFD may have been opened from a stream. */ 1237 if (abfd->filename == NULL) 1238 { 1239 bfd_set_error (bfd_error_invalid_operation); 1240 return NULL; 1241 } 1242 1243 basename = get_debug_link_info (abfd, & crc32); 1244 if (basename == NULL) 1245 return NULL; 1246 1247 if (basename[0] == '\0') 1248 { 1249 free (basename); 1250 bfd_set_error (bfd_error_no_debug_section); 1251 return NULL; 1252 } 1253 1254 for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--) 1255 if (IS_DIR_SEPARATOR (abfd->filename[dirlen - 1])) 1256 break; 1257 1258 dir = bfd_malloc (dirlen + 1); 1259 if (dir == NULL) 1260 { 1261 free (basename); 1262 return NULL; 1263 } 1264 memcpy (dir, abfd->filename, dirlen); 1265 dir[dirlen] = '\0'; 1266 1267 /* Compute the canonical name of the bfd object with all symbolic links 1268 resolved, for use in the global debugfile directory. */ 1269 canon_dir = lrealpath (abfd->filename); 1270 for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--) 1271 if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1])) 1272 break; 1273 canon_dir[canon_dirlen] = '\0'; 1274 1275 debugfile = bfd_malloc (strlen (debug_file_directory) + 1 1276 + (canon_dirlen > dirlen ? canon_dirlen : dirlen) 1277 + strlen (".debug/") 1278 + strlen (basename) 1279 + 1); 1280 if (debugfile == NULL) 1281 { 1282 free (basename); 1283 free (dir); 1284 free (canon_dir); 1285 return NULL; 1286 } 1287 1288 /* First try in the same directory as the original file: */ 1289 strcpy (debugfile, dir); 1290 strcat (debugfile, basename); 1291 1292 if (separate_debug_file_exists (debugfile, crc32)) 1293 { 1294 free (basename); 1295 free (dir); 1296 free (canon_dir); 1297 return debugfile; 1298 } 1299 1300 /* Then try in a subdirectory called .debug. */ 1301 strcpy (debugfile, dir); 1302 strcat (debugfile, ".debug/"); 1303 strcat (debugfile, basename); 1304 1305 if (separate_debug_file_exists (debugfile, crc32)) 1306 { 1307 free (basename); 1308 free (dir); 1309 free (canon_dir); 1310 return debugfile; 1311 } 1312 1313 /* Then try in the global debugfile directory. */ 1314 strcpy (debugfile, debug_file_directory); 1315 dirlen = strlen (debug_file_directory) - 1; 1316 if (dirlen > 0 1317 && debug_file_directory[dirlen] != '/' 1318 && canon_dir[0] != '/') 1319 strcat (debugfile, "/"); 1320 strcat (debugfile, canon_dir); 1321 strcat (debugfile, basename); 1322 1323 if (separate_debug_file_exists (debugfile, crc32)) 1324 { 1325 free (basename); 1326 free (dir); 1327 free (canon_dir); 1328 return debugfile; 1329 } 1330 1331 free (debugfile); 1332 free (basename); 1333 free (dir); 1334 free (canon_dir); 1335 return NULL; 1336 } 1337 1338 1339 /* 1340 FUNCTION 1341 bfd_follow_gnu_debuglink 1342 1343 SYNOPSIS 1344 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir); 1345 1346 DESCRIPTION 1347 1348 Takes a BFD and searches it for a .gnu_debuglink section. If this 1349 section is found, it examines the section for the name and checksum 1350 of a '.debug' file containing auxiliary debugging information. It 1351 then searches the filesystem for this .debug file in some standard 1352 locations, including the directory tree rooted at @var{dir}, and if 1353 found returns the full filename. 1354 1355 If @var{dir} is NULL, it will search a default path configured into 1356 libbfd at build time. [XXX this feature is not currently 1357 implemented]. 1358 1359 RETURNS 1360 <<NULL>> on any errors or failure to locate the .debug file, 1361 otherwise a pointer to a heap-allocated string containing the 1362 filename. The caller is responsible for freeing this string. 1363 */ 1364 1365 char * 1366 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir) 1367 { 1368 return find_separate_debug_file (abfd, dir); 1369 } 1370 1371 /* 1372 FUNCTION 1373 bfd_create_gnu_debuglink_section 1374 1375 SYNOPSIS 1376 struct bfd_section *bfd_create_gnu_debuglink_section 1377 (bfd *abfd, const char *filename); 1378 1379 DESCRIPTION 1380 1381 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The section is sized 1382 to be big enough to contain a link to the specified @var{filename}. 1383 1384 RETURNS 1385 A pointer to the new section is returned if all is ok. Otherwise <<NULL>> is 1386 returned and bfd_error is set. 1387 */ 1388 1389 asection * 1390 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename) 1391 { 1392 asection *sect; 1393 bfd_size_type debuglink_size; 1394 flagword flags; 1395 1396 if (abfd == NULL || filename == NULL) 1397 { 1398 bfd_set_error (bfd_error_invalid_operation); 1399 return NULL; 1400 } 1401 1402 /* Strip off any path components in filename. */ 1403 filename = lbasename (filename); 1404 1405 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK); 1406 if (sect) 1407 { 1408 /* Section already exists. */ 1409 bfd_set_error (bfd_error_invalid_operation); 1410 return NULL; 1411 } 1412 1413 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING; 1414 sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags); 1415 if (sect == NULL) 1416 return NULL; 1417 1418 debuglink_size = strlen (filename) + 1; 1419 debuglink_size += 3; 1420 debuglink_size &= ~3; 1421 debuglink_size += 4; 1422 1423 if (! bfd_set_section_size (abfd, sect, debuglink_size)) 1424 /* XXX Should we delete the section from the bfd ? */ 1425 return NULL; 1426 1427 return sect; 1428 } 1429 1430 1431 /* 1432 FUNCTION 1433 bfd_fill_in_gnu_debuglink_section 1434 1435 SYNOPSIS 1436 bfd_boolean bfd_fill_in_gnu_debuglink_section 1437 (bfd *abfd, struct bfd_section *sect, const char *filename); 1438 1439 DESCRIPTION 1440 1441 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT} 1442 and fills in the contents of the section to contain a link to the 1443 specified @var{filename}. The filename should be relative to the 1444 current directory. 1445 1446 RETURNS 1447 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned 1448 and bfd_error is set. 1449 */ 1450 1451 bfd_boolean 1452 bfd_fill_in_gnu_debuglink_section (bfd *abfd, 1453 struct bfd_section *sect, 1454 const char *filename) 1455 { 1456 bfd_size_type debuglink_size; 1457 unsigned long crc32; 1458 char * contents; 1459 bfd_size_type crc_offset; 1460 FILE * handle; 1461 static unsigned char buffer[8 * 1024]; 1462 size_t count; 1463 size_t filelen; 1464 1465 if (abfd == NULL || sect == NULL || filename == NULL) 1466 { 1467 bfd_set_error (bfd_error_invalid_operation); 1468 return FALSE; 1469 } 1470 1471 /* Make sure that we can read the file. 1472 XXX - Should we attempt to locate the debug info file using the same 1473 algorithm as gdb ? At the moment, since we are creating the 1474 .gnu_debuglink section, we insist upon the user providing us with a 1475 correct-for-section-creation-time path, but this need not conform to 1476 the gdb location algorithm. */ 1477 handle = real_fopen (filename, FOPEN_RB); 1478 if (handle == NULL) 1479 { 1480 bfd_set_error (bfd_error_system_call); 1481 return FALSE; 1482 } 1483 1484 crc32 = 0; 1485 while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0) 1486 crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count); 1487 fclose (handle); 1488 1489 /* Strip off any path components in filename, 1490 now that we no longer need them. */ 1491 filename = lbasename (filename); 1492 1493 filelen = strlen (filename); 1494 debuglink_size = filelen + 1; 1495 debuglink_size += 3; 1496 debuglink_size &= ~3; 1497 debuglink_size += 4; 1498 1499 contents = bfd_malloc (debuglink_size); 1500 if (contents == NULL) 1501 { 1502 /* XXX Should we delete the section from the bfd ? */ 1503 return FALSE; 1504 } 1505 1506 crc_offset = debuglink_size - 4; 1507 memcpy (contents, filename, filelen); 1508 memset (contents + filelen, 0, crc_offset - filelen); 1509 1510 bfd_put_32 (abfd, crc32, contents + crc_offset); 1511 1512 if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size)) 1513 { 1514 /* XXX Should we delete the section from the bfd ? */ 1515 free (contents); 1516 return FALSE; 1517 } 1518 1519 return TRUE; 1520 } 1521