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 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 43static 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 50bfd * 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 98bfd * 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 116void 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 129bfd_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/* 149SECTION 150 Opening and closing BFDs 151 152SUBSECTION 153 Functions for opening and closing 154*/ 155 156/* 157FUNCTION 158 bfd_fopen 159 160SYNOPSIS 161 bfd *bfd_fopen (const char *filename, const char *target, 162 const char *mode, int fd); 163 164DESCRIPTION 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 181bfd * 182bfd_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/* 241FUNCTION 242 bfd_openr 243 244SYNOPSIS 245 bfd *bfd_openr (const char *filename, const char *target); 246 247DESCRIPTION 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 259bfd * 260bfd_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/* 273FUNCTION 274 bfd_fdopenr 275 276SYNOPSIS 277 bfd *bfd_fdopenr (const char *filename, const char *target, int fd); 278 279DESCRIPTION 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 298bfd * 299bfd_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/* 330FUNCTION 331 bfd_openstreamr 332 333SYNOPSIS 334 bfd *bfd_openstreamr (const char *, const char *, void *); 335 336DESCRIPTION 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 342bfd * 343bfd_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/* 374FUNCTION 375 bfd_openr_iovec 376 377SYNOPSIS 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 393DESCRIPTION 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 428struct 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 438static file_ptr 439opncls_btell (struct bfd *abfd) 440{ 441 struct opncls *vec = abfd->iostream; 442 return vec->where; 443} 444 445static int 446opncls_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 458static file_ptr 459opncls_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 469static file_ptr 470opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED, 471 const void *where ATTRIBUTE_UNUSED, 472 file_ptr nbytes ATTRIBUTE_UNUSED) 473{ 474 return -1; 475} 476 477static int 478opncls_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 490static int 491opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED) 492{ 493 return 0; 494} 495 496static int 497opncls_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 508static const struct bfd_iovec opncls_iovec = { 509 &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek, 510 &opncls_bclose, &opncls_bflush, &opncls_bstat 511}; 512 513bfd * 514bfd_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/* 574FUNCTION 575 bfd_openw 576 577SYNOPSIS 578 bfd *bfd_openw (const char *filename, const char *target); 579 580DESCRIPTION 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 588bfd * 589bfd_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 623FUNCTION 624 bfd_close 625 626SYNOPSIS 627 bfd_boolean bfd_close (bfd *abfd); 628 629DESCRIPTION 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 641RETURNS 642 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. 643*/ 644 645 646bfd_boolean 647bfd_close (bfd *abfd) 648{ 649 bfd_boolean ret; 650 651 if (bfd_write_p (abfd)) 652 { 653 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) 654 return FALSE; 655 } 656 657 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) 658 return FALSE; 659 660 /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io 661 vector. */ 662 if (!(abfd->flags & BFD_IN_MEMORY)) 663 ret = abfd->iovec->bclose (abfd); 664 else 665 ret = TRUE; 666 667 /* If the file was open for writing and is now executable, 668 make it so. */ 669 if (ret 670 && abfd->direction == write_direction 671 && abfd->flags & EXEC_P) 672 { 673 struct stat buf; 674 675 if (stat (abfd->filename, &buf) == 0) 676 { 677 unsigned int mask = umask (0); 678 679 umask (mask); 680 chmod (abfd->filename, 681 (0777 682 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); 683 } 684 } 685 686 _bfd_delete_bfd (abfd); 687 688 return ret; 689} 690 691/* 692FUNCTION 693 bfd_close_all_done 694 695SYNOPSIS 696 bfd_boolean bfd_close_all_done (bfd *); 697 698DESCRIPTION 699 Close a BFD. Differs from <<bfd_close>> since it does not 700 complete any pending operations. This routine would be used 701 if the application had just used BFD for swapping and didn't 702 want to use any of the writing code. 703 704 If the created file is executable, then <<chmod>> is called 705 to mark it as such. 706 707 All memory attached to the BFD is released. 708 709RETURNS 710 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. 711*/ 712 713bfd_boolean 714bfd_close_all_done (bfd *abfd) 715{ 716 bfd_boolean ret; 717 718 ret = bfd_cache_close (abfd); 719 720 /* If the file was open for writing and is now executable, 721 make it so. */ 722 if (ret 723 && abfd->direction == write_direction 724 && abfd->flags & EXEC_P) 725 { 726 struct stat buf; 727 728 if (stat (abfd->filename, &buf) == 0) 729 { 730 unsigned int mask = umask (0); 731 732 umask (mask); 733 chmod (abfd->filename, 734 (0777 735 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); 736 } 737 } 738 739 _bfd_delete_bfd (abfd); 740 741 return ret; 742} 743 744/* 745FUNCTION 746 bfd_create 747 748SYNOPSIS 749 bfd *bfd_create (const char *filename, bfd *templ); 750 751DESCRIPTION 752 Create a new BFD in the manner of <<bfd_openw>>, but without 753 opening a file. The new BFD takes the target from the target 754 used by @var{template}. The format is always set to <<bfd_object>>. 755*/ 756 757bfd * 758bfd_create (const char *filename, bfd *templ) 759{ 760 bfd *nbfd; 761 762 nbfd = _bfd_new_bfd (); 763 if (nbfd == NULL) 764 return NULL; 765 nbfd->filename = filename; 766 if (templ) 767 nbfd->xvec = templ->xvec; 768 nbfd->direction = no_direction; 769 bfd_set_format (nbfd, bfd_object); 770 771 return nbfd; 772} 773 774/* 775FUNCTION 776 bfd_make_writable 777 778SYNOPSIS 779 bfd_boolean bfd_make_writable (bfd *abfd); 780 781DESCRIPTION 782 Takes a BFD as created by <<bfd_create>> and converts it 783 into one like as returned by <<bfd_openw>>. It does this 784 by converting the BFD to BFD_IN_MEMORY. It's assumed that 785 you will call <<bfd_make_readable>> on this bfd later. 786 787RETURNS 788 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. 789*/ 790 791bfd_boolean 792bfd_make_writable (bfd *abfd) 793{ 794 struct bfd_in_memory *bim; 795 796 if (abfd->direction != no_direction) 797 { 798 bfd_set_error (bfd_error_invalid_operation); 799 return FALSE; 800 } 801 802 bim = bfd_malloc (sizeof (struct bfd_in_memory)); 803 if (bim == NULL) 804 return FALSE; /* bfd_error already set. */ 805 abfd->iostream = bim; 806 /* bfd_bwrite will grow these as needed. */ 807 bim->size = 0; 808 bim->buffer = 0; 809 810 abfd->flags |= BFD_IN_MEMORY; 811 abfd->direction = write_direction; 812 abfd->where = 0; 813 814 return TRUE; 815} 816 817/* 818FUNCTION 819 bfd_make_readable 820 821SYNOPSIS 822 bfd_boolean bfd_make_readable (bfd *abfd); 823 824DESCRIPTION 825 Takes a BFD as created by <<bfd_create>> and 826 <<bfd_make_writable>> and converts it into one like as 827 returned by <<bfd_openr>>. It does this by writing the 828 contents out to the memory buffer, then reversing the 829 direction. 830 831RETURNS 832 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */ 833 834bfd_boolean 835bfd_make_readable (bfd *abfd) 836{ 837 if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY)) 838 { 839 bfd_set_error (bfd_error_invalid_operation); 840 return FALSE; 841 } 842 843 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) 844 return FALSE; 845 846 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) 847 return FALSE; 848 849 850 abfd->arch_info = &bfd_default_arch_struct; 851 852 abfd->where = 0; 853 abfd->format = bfd_unknown; 854 abfd->my_archive = NULL; 855 abfd->origin = 0; 856 abfd->opened_once = FALSE; 857 abfd->output_has_begun = FALSE; 858 abfd->section_count = 0; 859 abfd->usrdata = NULL; 860 abfd->cacheable = FALSE; 861 abfd->flags = BFD_IN_MEMORY; 862 abfd->mtime_set = FALSE; 863 864 abfd->target_defaulted = TRUE; 865 abfd->direction = read_direction; 866 abfd->sections = 0; 867 abfd->symcount = 0; 868 abfd->outsymbols = 0; 869 abfd->tdata.any = 0; 870 871 bfd_section_list_clear (abfd); 872 bfd_check_format (abfd, bfd_object); 873 874 return TRUE; 875} 876 877/* 878INTERNAL_FUNCTION 879 bfd_alloc 880 881SYNOPSIS 882 void *bfd_alloc (bfd *abfd, bfd_size_type wanted); 883 884DESCRIPTION 885 Allocate a block of @var{wanted} bytes of memory attached to 886 <<abfd>> and return a pointer to it. 887*/ 888 889void * 890bfd_alloc (bfd *abfd, bfd_size_type size) 891{ 892 void *ret; 893 894 if (size != (unsigned long) size) 895 { 896 bfd_set_error (bfd_error_no_memory); 897 return NULL; 898 } 899 900 ret = objalloc_alloc (abfd->memory, (unsigned long) size); 901 if (ret == NULL) 902 bfd_set_error (bfd_error_no_memory); 903 return ret; 904} 905 906/* 907INTERNAL_FUNCTION 908 bfd_alloc2 909 910SYNOPSIS 911 void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size); 912 913DESCRIPTION 914 Allocate a block of @var{nmemb} elements of @var{size} bytes each 915 of memory attached to <<abfd>> and return a pointer to it. 916*/ 917 918void * 919bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size) 920{ 921 void *ret; 922 923 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE 924 && size != 0 925 && nmemb > ~(bfd_size_type) 0 / size) 926 { 927 bfd_set_error (bfd_error_no_memory); 928 return NULL; 929 } 930 931 size *= nmemb; 932 933 if (size != (unsigned long) size) 934 { 935 bfd_set_error (bfd_error_no_memory); 936 return NULL; 937 } 938 939 ret = objalloc_alloc (abfd->memory, (unsigned long) size); 940 if (ret == NULL) 941 bfd_set_error (bfd_error_no_memory); 942 return ret; 943} 944 945/* 946INTERNAL_FUNCTION 947 bfd_zalloc 948 949SYNOPSIS 950 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted); 951 952DESCRIPTION 953 Allocate a block of @var{wanted} bytes of zeroed memory 954 attached to <<abfd>> and return a pointer to it. 955*/ 956 957void * 958bfd_zalloc (bfd *abfd, bfd_size_type size) 959{ 960 void *res; 961 962 res = bfd_alloc (abfd, size); 963 if (res) 964 memset (res, 0, (size_t) size); 965 return res; 966} 967 968/* 969INTERNAL_FUNCTION 970 bfd_zalloc2 971 972SYNOPSIS 973 void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size); 974 975DESCRIPTION 976 Allocate a block of @var{nmemb} elements of @var{size} bytes each 977 of zeroed memory attached to <<abfd>> and return a pointer to it. 978*/ 979 980void * 981bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size) 982{ 983 void *res; 984 985 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE 986 && size != 0 987 && nmemb > ~(bfd_size_type) 0 / size) 988 { 989 bfd_set_error (bfd_error_no_memory); 990 return NULL; 991 } 992 993 size *= nmemb; 994 995 res = bfd_alloc (abfd, size); 996 if (res) 997 memset (res, 0, (size_t) size); 998 return res; 999} 1000 1001/* Free a block allocated for a BFD. 1002 Note: Also frees all more recently allocated blocks! */ 1003 1004void 1005bfd_release (bfd *abfd, void *block) 1006{ 1007 objalloc_free_block ((struct objalloc *) abfd->memory, block); 1008} 1009 1010 1011/* 1012 GNU Extension: separate debug-info files 1013 1014 The idea here is that a special section called .gnu_debuglink might be 1015 embedded in a binary file, which indicates that some *other* file 1016 contains the real debugging information. This special section contains a 1017 filename and CRC32 checksum, which we read and resolve to another file, 1018 if it exists. 1019 1020 This facilitates "optional" provision of debugging information, without 1021 having to provide two complete copies of every binary object (with and 1022 without debug symbols). 1023*/ 1024 1025#define GNU_DEBUGLINK ".gnu_debuglink" 1026/* 1027FUNCTION 1028 bfd_calc_gnu_debuglink_crc32 1029 1030SYNOPSIS 1031 unsigned long bfd_calc_gnu_debuglink_crc32 1032 (unsigned long crc, const unsigned char *buf, bfd_size_type len); 1033 1034DESCRIPTION 1035 Computes a CRC value as used in the .gnu_debuglink section. 1036 Advances the previously computed @var{crc} value by computing 1037 and adding in the crc32 for @var{len} bytes of @var{buf}. 1038 1039RETURNS 1040 Return the updated CRC32 value. 1041*/ 1042 1043unsigned long 1044bfd_calc_gnu_debuglink_crc32 (unsigned long crc, 1045 const unsigned char *buf, 1046 bfd_size_type len) 1047{ 1048 static const unsigned long crc32_table[256] = 1049 { 1050 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 1051 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 1052 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 1053 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 1054 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 1055 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 1056 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 1057 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 1058 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 1059 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 1060 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 1061 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 1062 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 1063 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 1064 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 1065 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 1066 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 1067 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 1068 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 1069 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 1070 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 1071 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 1072 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 1073 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 1074 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 1075 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 1076 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 1077 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 1078 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 1079 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 1080 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 1081 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 1082 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 1083 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 1084 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 1085 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 1086 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 1087 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 1088 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 1089 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 1090 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 1091 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 1092 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 1093 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 1094 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 1095 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 1096 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 1097 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 1098 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 1099 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 1100 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 1101 0x2d02ef8d 1102 }; 1103 const unsigned char *end; 1104 1105 crc = ~crc & 0xffffffff; 1106 for (end = buf + len; buf < end; ++ buf) 1107 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8); 1108 return ~crc & 0xffffffff;; 1109} 1110 1111 1112/* 1113INTERNAL_FUNCTION 1114 get_debug_link_info 1115 1116SYNOPSIS 1117 char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out); 1118 1119DESCRIPTION 1120 fetch the filename and CRC32 value for any separate debuginfo 1121 associated with @var{abfd}. Return NULL if no such info found, 1122 otherwise return filename and update @var{crc32_out}. 1123*/ 1124 1125static char * 1126get_debug_link_info (bfd *abfd, unsigned long *crc32_out) 1127{ 1128 asection *sect; 1129 unsigned long crc32; 1130 bfd_byte *contents; 1131 int crc_offset; 1132 char *name; 1133 1134 BFD_ASSERT (abfd); 1135 BFD_ASSERT (crc32_out); 1136 1137 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK); 1138 1139 if (sect == NULL) 1140 return NULL; 1141 1142 if (!bfd_malloc_and_get_section (abfd, sect, &contents)) 1143 { 1144 if (contents != NULL) 1145 free (contents); 1146 return NULL; 1147 } 1148 1149 /* Crc value is stored after the filename, aligned up to 4 bytes. */ 1150 name = (char *) contents; 1151 crc_offset = strlen (name) + 1; 1152 crc_offset = (crc_offset + 3) & ~3; 1153 1154 crc32 = bfd_get_32 (abfd, contents + crc_offset); 1155 1156 *crc32_out = crc32; 1157 return name; 1158} 1159 1160/* 1161INTERNAL_FUNCTION 1162 separate_debug_file_exists 1163 1164SYNOPSIS 1165 bfd_boolean separate_debug_file_exists 1166 (char *name, unsigned long crc32); 1167 1168DESCRIPTION 1169 Checks to see if @var{name} is a file and if its contents 1170 match @var{crc32}. 1171*/ 1172 1173static bfd_boolean 1174separate_debug_file_exists (const char *name, const unsigned long crc) 1175{ 1176 static unsigned char buffer [8 * 1024]; 1177 unsigned long file_crc = 0; 1178 int fd; 1179 bfd_size_type count; 1180 1181 BFD_ASSERT (name); 1182 1183 fd = open (name, O_RDONLY); 1184 if (fd < 0) 1185 return FALSE; 1186 1187 while ((count = read (fd, buffer, sizeof (buffer))) > 0) 1188 file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count); 1189 1190 close (fd); 1191 1192 return crc == file_crc; 1193} 1194 1195 1196/* 1197INTERNAL_FUNCTION 1198 find_separate_debug_file 1199 1200SYNOPSIS 1201 char *find_separate_debug_file (bfd *abfd); 1202 1203DESCRIPTION 1204 Searches @var{abfd} for a reference to separate debugging 1205 information, scans various locations in the filesystem, including 1206 the file tree rooted at @var{debug_file_directory}, and returns a 1207 filename of such debugging information if the file is found and has 1208 matching CRC32. Returns NULL if no reference to debugging file 1209 exists, or file cannot be found. 1210*/ 1211 1212static char * 1213find_separate_debug_file (bfd *abfd, const char *debug_file_directory) 1214{ 1215 char *basename; 1216 char *dir; 1217 char *debugfile; 1218 unsigned long crc32; 1219 int i; 1220 1221 BFD_ASSERT (abfd); 1222 if (debug_file_directory == NULL) 1223 debug_file_directory = "."; 1224 1225 /* BFD may have been opened from a stream. */ 1226 if (! abfd->filename) 1227 return NULL; 1228 1229 basename = get_debug_link_info (abfd, & crc32); 1230 if (basename == NULL) 1231 return NULL; 1232 1233 if (strlen (basename) < 1) 1234 { 1235 free (basename); 1236 return NULL; 1237 } 1238 1239 dir = strdup (abfd->filename); 1240 if (dir == NULL) 1241 { 1242 free (basename); 1243 return NULL; 1244 } 1245 BFD_ASSERT (strlen (dir) != 0); 1246 1247 /* Strip off filename part. */ 1248 for (i = strlen (dir) - 1; i >= 0; i--) 1249 if (IS_DIR_SEPARATOR (dir[i])) 1250 break; 1251 1252 dir[i + 1] = '\0'; 1253 BFD_ASSERT (dir[i] == '/' || dir[0] == '\0'); 1254 1255 debugfile = malloc (strlen (debug_file_directory) + 1 1256 + strlen (dir) 1257 + strlen (".debug/") 1258 + strlen (basename) 1259 + 1); 1260 if (debugfile == NULL) 1261 { 1262 free (basename); 1263 free (dir); 1264 return NULL; 1265 } 1266 1267 /* First try in the same directory as the original file: */ 1268 strcpy (debugfile, dir); 1269 strcat (debugfile, basename); 1270 1271 if (separate_debug_file_exists (debugfile, crc32)) 1272 { 1273 free (basename); 1274 free (dir); 1275 return debugfile; 1276 } 1277 1278 /* Then try in a subdirectory called .debug. */ 1279 strcpy (debugfile, dir); 1280 strcat (debugfile, ".debug/"); 1281 strcat (debugfile, basename); 1282 1283 if (separate_debug_file_exists (debugfile, crc32)) 1284 { 1285 free (basename); 1286 free (dir); 1287 return debugfile; 1288 } 1289 1290 /* Then try in the global debugfile directory. */ 1291 strcpy (debugfile, debug_file_directory); 1292 i = strlen (debug_file_directory) - 1; 1293 if (i > 0 1294 && debug_file_directory[i] != '/' 1295 && dir[0] != '/') 1296 strcat (debugfile, "/"); 1297 strcat (debugfile, dir); 1298 strcat (debugfile, basename); 1299 1300 if (separate_debug_file_exists (debugfile, crc32)) 1301 { 1302 free (basename); 1303 free (dir); 1304 return debugfile; 1305 } 1306 1307 free (debugfile); 1308 free (basename); 1309 free (dir); 1310 return NULL; 1311} 1312 1313 1314/* 1315FUNCTION 1316 bfd_follow_gnu_debuglink 1317 1318SYNOPSIS 1319 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir); 1320 1321DESCRIPTION 1322 1323 Takes a BFD and searches it for a .gnu_debuglink section. If this 1324 section is found, it examines the section for the name and checksum 1325 of a '.debug' file containing auxiliary debugging information. It 1326 then searches the filesystem for this .debug file in some standard 1327 locations, including the directory tree rooted at @var{dir}, and if 1328 found returns the full filename. 1329 1330 If @var{dir} is NULL, it will search a default path configured into 1331 libbfd at build time. [XXX this feature is not currently 1332 implemented]. 1333 1334RETURNS 1335 <<NULL>> on any errors or failure to locate the .debug file, 1336 otherwise a pointer to a heap-allocated string containing the 1337 filename. The caller is responsible for freeing this string. 1338*/ 1339 1340char * 1341bfd_follow_gnu_debuglink (bfd *abfd, const char *dir) 1342{ 1343 return find_separate_debug_file (abfd, dir); 1344} 1345 1346/* 1347FUNCTION 1348 bfd_create_gnu_debuglink_section 1349 1350SYNOPSIS 1351 struct bfd_section *bfd_create_gnu_debuglink_section 1352 (bfd *abfd, const char *filename); 1353 1354DESCRIPTION 1355 1356 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The section is sized 1357 to be big enough to contain a link to the specified @var{filename}. 1358 1359RETURNS 1360 A pointer to the new section is returned if all is ok. Otherwise <<NULL>> is 1361 returned and bfd_error is set. 1362*/ 1363 1364asection * 1365bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename) 1366{ 1367 asection *sect; 1368 bfd_size_type debuglink_size; 1369 flagword flags; 1370 1371 if (abfd == NULL || filename == NULL) 1372 { 1373 bfd_set_error (bfd_error_invalid_operation); 1374 return NULL; 1375 } 1376 1377 /* Strip off any path components in filename. */ 1378 filename = lbasename (filename); 1379 1380 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK); 1381 if (sect) 1382 { 1383 /* Section already exists. */ 1384 bfd_set_error (bfd_error_invalid_operation); 1385 return NULL; 1386 } 1387 1388 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING; 1389 sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags); 1390 if (sect == NULL) 1391 return NULL; 1392 1393 debuglink_size = strlen (filename) + 1; 1394 debuglink_size += 3; 1395 debuglink_size &= ~3; 1396 debuglink_size += 4; 1397 1398 if (! bfd_set_section_size (abfd, sect, debuglink_size)) 1399 /* XXX Should we delete the section from the bfd ? */ 1400 return NULL; 1401 1402 return sect; 1403} 1404 1405 1406/* 1407FUNCTION 1408 bfd_fill_in_gnu_debuglink_section 1409 1410SYNOPSIS 1411 bfd_boolean bfd_fill_in_gnu_debuglink_section 1412 (bfd *abfd, struct bfd_section *sect, const char *filename); 1413 1414DESCRIPTION 1415 1416 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT} 1417 and fills in the contents of the section to contain a link to the 1418 specified @var{filename}. The filename should be relative to the 1419 current directory. 1420 1421RETURNS 1422 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned 1423 and bfd_error is set. 1424*/ 1425 1426bfd_boolean 1427bfd_fill_in_gnu_debuglink_section (bfd *abfd, 1428 struct bfd_section *sect, 1429 const char *filename) 1430{ 1431 bfd_size_type debuglink_size; 1432 unsigned long crc32; 1433 char * contents; 1434 bfd_size_type crc_offset; 1435 FILE * handle; 1436 static unsigned char buffer[8 * 1024]; 1437 size_t count; 1438 1439 if (abfd == NULL || sect == NULL || filename == NULL) 1440 { 1441 bfd_set_error (bfd_error_invalid_operation); 1442 return FALSE; 1443 } 1444 1445 /* Make sure that we can read the file. 1446 XXX - Should we attempt to locate the debug info file using the same 1447 algorithm as gdb ? At the moment, since we are creating the 1448 .gnu_debuglink section, we insist upon the user providing us with a 1449 correct-for-section-creation-time path, but this need not conform to 1450 the gdb location algorithm. */ 1451 handle = real_fopen (filename, FOPEN_RB); 1452 if (handle == NULL) 1453 { 1454 bfd_set_error (bfd_error_system_call); 1455 return FALSE; 1456 } 1457 1458 crc32 = 0; 1459 while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0) 1460 crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count); 1461 fclose (handle); 1462 1463 /* Strip off any path components in filename, 1464 now that we no longer need them. */ 1465 filename = lbasename (filename); 1466 1467 debuglink_size = strlen (filename) + 1; 1468 debuglink_size += 3; 1469 debuglink_size &= ~3; 1470 debuglink_size += 4; 1471 1472 contents = malloc (debuglink_size); 1473 if (contents == NULL) 1474 { 1475 /* XXX Should we delete the section from the bfd ? */ 1476 bfd_set_error (bfd_error_no_memory); 1477 return FALSE; 1478 } 1479 1480 strcpy (contents, filename); 1481 crc_offset = debuglink_size - 4; 1482 1483 bfd_put_32 (abfd, crc32, contents + crc_offset); 1484 1485 if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size)) 1486 { 1487 /* XXX Should we delete the section from the bfd ? */ 1488 free (contents); 1489 return FALSE; 1490 } 1491 1492 return TRUE; 1493} 1494