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