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