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