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