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