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