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