1/* opncls.c -- open and close a BFD. 2 Copyright (C) 1990-2022 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#include "elf-bfd.h" 29 30#ifndef S_IXUSR 31#define S_IXUSR 0100 /* Execute by owner. */ 32#endif 33#ifndef S_IXGRP 34#define S_IXGRP 0010 /* Execute by group. */ 35#endif 36#ifndef S_IXOTH 37#define S_IXOTH 0001 /* Execute by others. */ 38#endif 39 40/* Counters used to initialize the bfd identifier. */ 41 42static unsigned int bfd_id_counter = 0; 43static unsigned int bfd_reserved_id_counter = 0; 44 45/* 46CODE_FRAGMENT 47.{* Set to N to open the next N BFDs using an alternate id space. *} 48.extern unsigned int bfd_use_reserved_id; 49*/ 50unsigned int bfd_use_reserved_id = 0; 51 52/* fdopen is a loser -- we should use stdio exclusively. Unfortunately 53 if we do that we can't use fcntl. */ 54 55/* Return a new BFD. All BFD's are allocated through this routine. */ 56 57bfd * 58_bfd_new_bfd (void) 59{ 60 bfd *nbfd; 61 62 nbfd = (bfd *) bfd_zmalloc (sizeof (bfd)); 63 if (nbfd == NULL) 64 return NULL; 65 66 if (bfd_use_reserved_id) 67 { 68 nbfd->id = --bfd_reserved_id_counter; 69 --bfd_use_reserved_id; 70 } 71 else 72 nbfd->id = bfd_id_counter++; 73 74 nbfd->memory = objalloc_create (); 75 if (nbfd->memory == NULL) 76 { 77 bfd_set_error (bfd_error_no_memory); 78 free (nbfd); 79 return NULL; 80 } 81 82 nbfd->arch_info = &bfd_default_arch_struct; 83 84 if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc, 85 sizeof (struct section_hash_entry), 13)) 86 { 87 objalloc_free ((struct objalloc *) nbfd->memory); 88 free (nbfd); 89 return NULL; 90 } 91 92 nbfd->archive_plugin_fd = -1; 93 94 return nbfd; 95} 96 97static const struct bfd_iovec opncls_iovec; 98 99/* Allocate a new BFD as a member of archive OBFD. */ 100 101bfd * 102_bfd_new_bfd_contained_in (bfd *obfd) 103{ 104 bfd *nbfd; 105 106 nbfd = _bfd_new_bfd (); 107 if (nbfd == NULL) 108 return NULL; 109 nbfd->xvec = obfd->xvec; 110 nbfd->iovec = obfd->iovec; 111 if (obfd->iovec == &opncls_iovec) 112 nbfd->iostream = obfd->iostream; 113 nbfd->my_archive = obfd; 114 nbfd->direction = read_direction; 115 nbfd->target_defaulted = obfd->target_defaulted; 116 nbfd->lto_output = obfd->lto_output; 117 nbfd->no_export = obfd->no_export; 118 return nbfd; 119} 120 121/* Delete a BFD. */ 122 123static void 124_bfd_delete_bfd (bfd *abfd) 125{ 126 if (abfd->memory) 127 { 128 bfd_hash_table_free (&abfd->section_htab); 129 objalloc_free ((struct objalloc *) abfd->memory); 130 } 131 else 132 free ((char *) bfd_get_filename (abfd)); 133 134 free (abfd->arelt_data); 135 free (abfd); 136} 137 138/* Free objalloc memory. */ 139 140bool 141_bfd_free_cached_info (bfd *abfd) 142{ 143 if (abfd->memory) 144 { 145 const char *filename = bfd_get_filename (abfd); 146 if (filename) 147 { 148 /* We can't afford to lose the bfd filename when freeing 149 abfd->memory, because that would kill the cache.c scheme 150 of closing and reopening files in order to limit the 151 number of open files. To reopen, you need the filename. 152 And indeed _bfd_compute_and_write_armap calls 153 _bfd_free_cached_info to free up space used by symbols 154 and by check_format_matches. Which we want to continue 155 doing to handle very large archives. Later the archive 156 elements are copied, which might require reopening files. 157 We also want to keep using objalloc memory for the 158 filename since that allows the name to be updated 159 without either leaking memory or implementing some sort 160 of reference counted string for copies of the filename. */ 161 size_t len = strlen (filename) + 1; 162 char *copy = bfd_malloc (len); 163 if (copy == NULL) 164 return false; 165 memcpy (copy, filename, len); 166 abfd->filename = copy; 167 } 168 bfd_hash_table_free (&abfd->section_htab); 169 objalloc_free ((struct objalloc *) abfd->memory); 170 171 abfd->sections = NULL; 172 abfd->section_last = NULL; 173 abfd->outsymbols = NULL; 174 abfd->tdata.any = NULL; 175 abfd->usrdata = NULL; 176 abfd->memory = NULL; 177 } 178 179 return true; 180} 181 182/* 183SECTION 184 Opening and closing BFDs 185 186SUBSECTION 187 Functions for opening and closing 188*/ 189 190/* 191FUNCTION 192 bfd_fopen 193 194SYNOPSIS 195 bfd *bfd_fopen (const char *filename, const char *target, 196 const char *mode, int fd); 197 198DESCRIPTION 199 Open the file @var{filename} with the target @var{target}. 200 Return a pointer to the created BFD. If @var{fd} is not -1, 201 then <<fdopen>> is used to open the file; otherwise, <<fopen>> 202 is used. @var{mode} is passed directly to <<fopen>> or 203 <<fdopen>>. 204 205 Calls <<bfd_find_target>>, so @var{target} is interpreted as by 206 that function. 207 208 The new BFD is marked as cacheable iff @var{fd} is -1. 209 210 If <<NULL>> is returned then an error has occured. Possible errors 211 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or 212 <<system_call>> error. 213 214 On error, @var{fd} is always closed. 215 216 A copy of the @var{filename} argument is stored in the newly created 217 BFD. It can be accessed via the bfd_get_filename() macro. 218*/ 219 220bfd * 221bfd_fopen (const char *filename, const char *target, const char *mode, int fd) 222{ 223 bfd *nbfd; 224 const bfd_target *target_vec; 225 226 nbfd = _bfd_new_bfd (); 227 if (nbfd == NULL) 228 { 229 if (fd != -1) 230 close (fd); 231 return NULL; 232 } 233 234 target_vec = bfd_find_target (target, nbfd); 235 if (target_vec == NULL) 236 { 237 if (fd != -1) 238 close (fd); 239 _bfd_delete_bfd (nbfd); 240 return NULL; 241 } 242 243#ifdef HAVE_FDOPEN 244 if (fd != -1) 245 nbfd->iostream = fdopen (fd, mode); 246 else 247#endif 248 nbfd->iostream = _bfd_real_fopen (filename, mode); 249 if (nbfd->iostream == NULL) 250 { 251 bfd_set_error (bfd_error_system_call); 252 if (fd != -1) 253 close (fd); 254 _bfd_delete_bfd (nbfd); 255 return NULL; 256 } 257 258 /* OK, put everything where it belongs. */ 259 260 /* PR 11983: Do not cache the original filename, but 261 rather make a copy - the original might go away. */ 262 if (!bfd_set_filename (nbfd, filename)) 263 { 264 fclose (nbfd->iostream); 265 _bfd_delete_bfd (nbfd); 266 return NULL; 267 } 268 269 /* Figure out whether the user is opening the file for reading, 270 writing, or both, by looking at the MODE argument. */ 271 if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a') 272 && mode[1] == '+') 273 nbfd->direction = both_direction; 274 else if (mode[0] == 'r') 275 nbfd->direction = read_direction; 276 else 277 nbfd->direction = write_direction; 278 279 if (!bfd_cache_init (nbfd)) 280 { 281 fclose (nbfd->iostream); 282 _bfd_delete_bfd (nbfd); 283 return NULL; 284 } 285 nbfd->opened_once = true; 286 287 /* If we opened the file by name, mark it cacheable; we can close it 288 and reopen it later. However, if a file descriptor was provided, 289 then it may have been opened with special flags that make it 290 unsafe to close and reopen the file. */ 291 if (fd == -1) 292 (void) bfd_set_cacheable (nbfd, true); 293 294 return nbfd; 295} 296 297/* 298FUNCTION 299 bfd_openr 300 301SYNOPSIS 302 bfd *bfd_openr (const char *filename, const char *target); 303 304DESCRIPTION 305 Open the file @var{filename} (using <<fopen>>) with the target 306 @var{target}. Return a pointer to the created BFD. 307 308 Calls <<bfd_find_target>>, so @var{target} is interpreted as by 309 that function. 310 311 If <<NULL>> is returned then an error has occured. Possible errors 312 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or 313 <<system_call>> error. 314 315 A copy of the @var{filename} argument is stored in the newly created 316 BFD. It can be accessed via the bfd_get_filename() macro. 317*/ 318 319bfd * 320bfd_openr (const char *filename, const char *target) 321{ 322 return bfd_fopen (filename, target, FOPEN_RB, -1); 323} 324 325/* Don't try to `optimize' this function: 326 327 o - We lock using stack space so that interrupting the locking 328 won't cause a storage leak. 329 o - We open the file stream last, since we don't want to have to 330 close it if anything goes wrong. Closing the stream means closing 331 the file descriptor too, even though we didn't open it. */ 332/* 333FUNCTION 334 bfd_fdopenr 335 336SYNOPSIS 337 bfd *bfd_fdopenr (const char *filename, const char *target, int fd); 338 339DESCRIPTION 340 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to 341 <<fopen>>. It opens a BFD on a file already described by the 342 @var{fd} supplied. 343 344 When the file is later <<bfd_close>>d, the file descriptor will 345 be closed. If the caller desires that this file descriptor be 346 cached by BFD (opened as needed, closed as needed to free 347 descriptors for other opens), with the supplied @var{fd} used as 348 an initial file descriptor (but subject to closure at any time), 349 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default 350 is to assume no caching; the file descriptor will remain open 351 until <<bfd_close>>, and will not be affected by BFD operations 352 on other files. 353 354 Possible errors are <<bfd_error_no_memory>>, 355 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>. 356 357 On error, @var{fd} is closed. 358 359 A copy of the @var{filename} argument is stored in the newly created 360 BFD. It can be accessed via the bfd_get_filename() macro. 361*/ 362 363bfd * 364bfd_fdopenr (const char *filename, const char *target, int fd) 365{ 366 const char *mode; 367#if defined(HAVE_FCNTL) && defined(F_GETFL) 368 int fdflags; 369#endif 370 371#if ! defined(HAVE_FCNTL) || ! defined(F_GETFL) 372 mode = FOPEN_RUB; /* Assume full access. */ 373#else 374 fdflags = fcntl (fd, F_GETFL, NULL); 375 if (fdflags == -1) 376 { 377 int save = errno; 378 379 close (fd); 380 errno = save; 381 bfd_set_error (bfd_error_system_call); 382 return NULL; 383 } 384 385 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */ 386 switch (fdflags & (O_ACCMODE)) 387 { 388 case O_RDONLY: mode = FOPEN_RB; break; 389 case O_WRONLY: mode = FOPEN_RUB; break; 390 case O_RDWR: mode = FOPEN_RUB; break; 391 default: abort (); 392 } 393#endif 394 395 return bfd_fopen (filename, target, mode, fd); 396} 397 398/* 399FUNCTION 400 bfd_fdopenw 401 402SYNOPSIS 403 bfd *bfd_fdopenw (const char *filename, const char *target, int fd); 404 405DESCRIPTION 406 <<bfd_fdopenw>> is exactly like <<bfd_fdopenr>> with the exception that 407 the resulting BFD is suitable for output. 408*/ 409 410bfd * 411bfd_fdopenw (const char *filename, const char *target, int fd) 412{ 413 bfd *out = bfd_fdopenr (filename, target, fd); 414 415 if (out != NULL) 416 { 417 if (!bfd_write_p (out)) 418 { 419 close (fd); 420 _bfd_delete_bfd (out); 421 out = NULL; 422 bfd_set_error (bfd_error_invalid_operation); 423 } 424 else 425 out->direction = write_direction; 426 } 427 428 return out; 429} 430 431/* 432FUNCTION 433 bfd_openstreamr 434 435SYNOPSIS 436 bfd *bfd_openstreamr (const char * filename, const char * target, 437 void * stream); 438 439DESCRIPTION 440 Open a BFD for read access on an existing stdio stream. When 441 the BFD is passed to <<bfd_close>>, the stream will be closed. 442 443 A copy of the @var{filename} argument is stored in the newly created 444 BFD. It can be accessed via the bfd_get_filename() macro. 445*/ 446 447bfd * 448bfd_openstreamr (const char *filename, const char *target, void *streamarg) 449{ 450 FILE *stream = (FILE *) streamarg; 451 bfd *nbfd; 452 const bfd_target *target_vec; 453 454 nbfd = _bfd_new_bfd (); 455 if (nbfd == NULL) 456 return NULL; 457 458 target_vec = bfd_find_target (target, nbfd); 459 if (target_vec == NULL) 460 { 461 _bfd_delete_bfd (nbfd); 462 return NULL; 463 } 464 465 nbfd->iostream = stream; 466 /* PR 11983: Do not cache the original filename, but 467 rather make a copy - the original might go away. */ 468 if (!bfd_set_filename (nbfd, filename)) 469 { 470 _bfd_delete_bfd (nbfd); 471 return NULL; 472 } 473 nbfd->direction = read_direction; 474 475 if (! bfd_cache_init (nbfd)) 476 { 477 _bfd_delete_bfd (nbfd); 478 return NULL; 479 } 480 481 return nbfd; 482} 483 484/* 485FUNCTION 486 bfd_openr_iovec 487 488SYNOPSIS 489 bfd *bfd_openr_iovec (const char *filename, const char *target, 490 void *(*open_func) (struct bfd *nbfd, 491 void *open_closure), 492 void *open_closure, 493 file_ptr (*pread_func) (struct bfd *nbfd, 494 void *stream, 495 void *buf, 496 file_ptr nbytes, 497 file_ptr offset), 498 int (*close_func) (struct bfd *nbfd, 499 void *stream), 500 int (*stat_func) (struct bfd *abfd, 501 void *stream, 502 struct stat *sb)); 503 504DESCRIPTION 505 Create and return a BFD backed by a read-only @var{stream}. 506 The @var{stream} is created using @var{open_func}, accessed using 507 @var{pread_func} and destroyed using @var{close_func}. 508 509 Calls <<bfd_find_target>>, so @var{target} is interpreted as by 510 that function. 511 512 Calls @var{open_func} (which can call <<bfd_zalloc>> and 513 <<bfd_get_filename>>) to obtain the read-only stream backing 514 the BFD. @var{open_func} either succeeds returning the 515 non-<<NULL>> @var{stream}, or fails returning <<NULL>> 516 (setting <<bfd_error>>). 517 518 Calls @var{pread_func} to request @var{nbytes} of data from 519 @var{stream} starting at @var{offset} (e.g., via a call to 520 <<bfd_read>>). @var{pread_func} either succeeds returning the 521 number of bytes read (which can be less than @var{nbytes} when 522 end-of-file), or fails returning -1 (setting <<bfd_error>>). 523 524 Calls @var{close_func} when the BFD is later closed using 525 <<bfd_close>>. @var{close_func} either succeeds returning 0, or 526 fails returning -1 (setting <<bfd_error>>). 527 528 Calls @var{stat_func} to fill in a stat structure for bfd_stat, 529 bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0 530 on success, or returns -1 on failure (setting <<bfd_error>>). 531 532 If <<bfd_openr_iovec>> returns <<NULL>> then an error has 533 occurred. Possible errors are <<bfd_error_no_memory>>, 534 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>. 535 536 A copy of the @var{filename} argument is stored in the newly created 537 BFD. It can be accessed via the bfd_get_filename() macro. 538*/ 539 540struct opncls 541{ 542 void *stream; 543 file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf, 544 file_ptr nbytes, file_ptr offset); 545 int (*close) (struct bfd *abfd, void *stream); 546 int (*stat) (struct bfd *abfd, void *stream, struct stat *sb); 547 file_ptr where; 548}; 549 550static file_ptr 551opncls_btell (struct bfd *abfd) 552{ 553 struct opncls *vec = (struct opncls *) abfd->iostream; 554 return vec->where; 555} 556 557static int 558opncls_bseek (struct bfd *abfd, file_ptr offset, int whence) 559{ 560 struct opncls *vec = (struct opncls *) abfd->iostream; 561 switch (whence) 562 { 563 case SEEK_SET: vec->where = offset; break; 564 case SEEK_CUR: vec->where += offset; break; 565 case SEEK_END: return -1; 566 } 567 return 0; 568} 569 570static file_ptr 571opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes) 572{ 573 struct opncls *vec = (struct opncls *) abfd->iostream; 574 file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where); 575 576 if (nread < 0) 577 return nread; 578 vec->where += nread; 579 return nread; 580} 581 582static file_ptr 583opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED, 584 const void *where ATTRIBUTE_UNUSED, 585 file_ptr nbytes ATTRIBUTE_UNUSED) 586{ 587 return -1; 588} 589 590static int 591opncls_bclose (struct bfd *abfd) 592{ 593 struct opncls *vec = (struct opncls *) abfd->iostream; 594 /* Since the VEC's memory is bound to the bfd deleting the bfd will 595 free it. */ 596 int status = 0; 597 598 if (vec->close != NULL) 599 status = (vec->close) (abfd, vec->stream); 600 abfd->iostream = NULL; 601 return status; 602} 603 604static int 605opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED) 606{ 607 return 0; 608} 609 610static int 611opncls_bstat (struct bfd *abfd, struct stat *sb) 612{ 613 struct opncls *vec = (struct opncls *) abfd->iostream; 614 615 memset (sb, 0, sizeof (*sb)); 616 if (vec->stat == NULL) 617 return 0; 618 619 return (vec->stat) (abfd, vec->stream, sb); 620} 621 622static void * 623opncls_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED, 624 void *addr ATTRIBUTE_UNUSED, 625 bfd_size_type len ATTRIBUTE_UNUSED, 626 int prot ATTRIBUTE_UNUSED, 627 int flags ATTRIBUTE_UNUSED, 628 file_ptr offset ATTRIBUTE_UNUSED, 629 void **map_addr ATTRIBUTE_UNUSED, 630 bfd_size_type *map_len ATTRIBUTE_UNUSED) 631{ 632 return (void *) -1; 633} 634 635static const struct bfd_iovec opncls_iovec = 636{ 637 &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek, 638 &opncls_bclose, &opncls_bflush, &opncls_bstat, &opncls_bmmap 639}; 640 641bfd * 642bfd_openr_iovec (const char *filename, const char *target, 643 void *(*open_p) (struct bfd *, void *), 644 void *open_closure, 645 file_ptr (*pread_p) (struct bfd *, void *, void *, 646 file_ptr, file_ptr), 647 int (*close_p) (struct bfd *, void *), 648 int (*stat_p) (struct bfd *, void *, struct stat *)) 649{ 650 bfd *nbfd; 651 const bfd_target *target_vec; 652 struct opncls *vec; 653 void *stream; 654 655 nbfd = _bfd_new_bfd (); 656 if (nbfd == NULL) 657 return NULL; 658 659 target_vec = bfd_find_target (target, nbfd); 660 if (target_vec == NULL) 661 { 662 _bfd_delete_bfd (nbfd); 663 return NULL; 664 } 665 666 /* PR 11983: Do not cache the original filename, but 667 rather make a copy - the original might go away. */ 668 if (!bfd_set_filename (nbfd, filename)) 669 { 670 _bfd_delete_bfd (nbfd); 671 return NULL; 672 } 673 nbfd->direction = read_direction; 674 675 /* `open_p (...)' would get expanded by an the open(2) syscall macro. */ 676 stream = (*open_p) (nbfd, open_closure); 677 if (stream == NULL) 678 { 679 _bfd_delete_bfd (nbfd); 680 return NULL; 681 } 682 683 vec = (struct opncls *) bfd_zalloc (nbfd, sizeof (struct opncls)); 684 vec->stream = stream; 685 vec->pread = pread_p; 686 vec->close = close_p; 687 vec->stat = stat_p; 688 689 nbfd->iovec = &opncls_iovec; 690 nbfd->iostream = vec; 691 692 return nbfd; 693} 694 695/* bfd_openw -- open for writing. 696 Returns a pointer to a freshly-allocated BFD on success, or NULL. 697 698 See comment by bfd_fdopenr before you try to modify this function. */ 699 700/* 701FUNCTION 702 bfd_openw 703 704SYNOPSIS 705 bfd *bfd_openw (const char *filename, const char *target); 706 707DESCRIPTION 708 Create a BFD, associated with file @var{filename}, using the 709 file format @var{target}, and return a pointer to it. 710 711 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>, 712 <<bfd_error_invalid_target>>. 713 714 A copy of the @var{filename} argument is stored in the newly created 715 BFD. It can be accessed via the bfd_get_filename() macro. 716*/ 717 718bfd * 719bfd_openw (const char *filename, const char *target) 720{ 721 bfd *nbfd; 722 const bfd_target *target_vec; 723 724 /* nbfd has to point to head of malloc'ed block so that bfd_close may 725 reclaim it correctly. */ 726 nbfd = _bfd_new_bfd (); 727 if (nbfd == NULL) 728 return NULL; 729 730 target_vec = bfd_find_target (target, nbfd); 731 if (target_vec == NULL) 732 { 733 _bfd_delete_bfd (nbfd); 734 return NULL; 735 } 736 737 /* PR 11983: Do not cache the original filename, but 738 rather make a copy - the original might go away. */ 739 if (!bfd_set_filename (nbfd, filename)) 740 { 741 _bfd_delete_bfd (nbfd); 742 return NULL; 743 } 744 nbfd->direction = write_direction; 745 746 if (bfd_open_file (nbfd) == NULL) 747 { 748 /* File not writeable, etc. */ 749 bfd_set_error (bfd_error_system_call); 750 _bfd_delete_bfd (nbfd); 751 return NULL; 752 } 753 754 return nbfd; 755} 756 757static inline void 758_maybe_make_executable (bfd * abfd) 759{ 760 /* If the file was open for writing and is now executable, 761 make it so. */ 762 if (abfd->direction == write_direction 763 && (abfd->flags & (EXEC_P | DYNAMIC)) != 0) 764 { 765 struct stat buf; 766 767 if (stat (bfd_get_filename (abfd), &buf) == 0 768 /* Do not attempt to change non-regular files. This is 769 here especially for configure scripts and kernel builds 770 which run tests with "ld [...] -o /dev/null". */ 771 && S_ISREG(buf.st_mode)) 772 { 773 unsigned int mask = umask (0); 774 775 umask (mask); 776 chmod (bfd_get_filename (abfd), 777 (0777 778 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); 779 } 780 } 781} 782 783/* 784FUNCTION 785 bfd_close 786 787SYNOPSIS 788 bool bfd_close (bfd *abfd); 789 790DESCRIPTION 791 Close a BFD. If the BFD was open for writing, then pending 792 operations are completed and the file written out and closed. 793 If the created file is executable, then <<chmod>> is called 794 to mark it as such. 795 796 All memory attached to the BFD is released. 797 798 The file descriptor associated with the BFD is closed (even 799 if it was passed in to BFD by <<bfd_fdopenr>>). 800 801RETURNS 802 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. 803*/ 804 805bool 806bfd_close (bfd *abfd) 807{ 808 if (bfd_write_p (abfd)) 809 { 810 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) 811 return false; 812 } 813 814 return bfd_close_all_done (abfd); 815} 816 817/* 818FUNCTION 819 bfd_close_all_done 820 821SYNOPSIS 822 bool bfd_close_all_done (bfd *); 823 824DESCRIPTION 825 Close a BFD. Differs from <<bfd_close>> since it does not 826 complete any pending operations. This routine would be used 827 if the application had just used BFD for swapping and didn't 828 want to use any of the writing code. 829 830 If the created file is executable, then <<chmod>> is called 831 to mark it as such. 832 833 All memory attached to the BFD is released. 834 835RETURNS 836 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. 837*/ 838 839bool 840bfd_close_all_done (bfd *abfd) 841{ 842 bool ret; 843 844 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) 845 return false; 846 847 ret = abfd->iovec->bclose (abfd) == 0; 848 849 if (ret) 850 _maybe_make_executable (abfd); 851 852 _bfd_delete_bfd (abfd); 853 854 return ret; 855} 856 857/* 858FUNCTION 859 bfd_create 860 861SYNOPSIS 862 bfd *bfd_create (const char *filename, bfd *templ); 863 864DESCRIPTION 865 Create a new BFD in the manner of <<bfd_openw>>, but without 866 opening a file. The new BFD takes the target from the target 867 used by @var{templ}. The format is always set to <<bfd_object>>. 868 869 A copy of the @var{filename} argument is stored in the newly created 870 BFD. It can be accessed via the bfd_get_filename() macro. 871*/ 872 873bfd * 874bfd_create (const char *filename, bfd *templ) 875{ 876 bfd *nbfd; 877 878 nbfd = _bfd_new_bfd (); 879 if (nbfd == NULL) 880 return NULL; 881 /* PR 11983: Do not cache the original filename, but 882 rather make a copy - the original might go away. */ 883 if (!bfd_set_filename (nbfd, filename)) 884 { 885 _bfd_delete_bfd (nbfd); 886 return NULL; 887 } 888 if (templ) 889 nbfd->xvec = templ->xvec; 890 nbfd->direction = no_direction; 891 bfd_set_format (nbfd, bfd_object); 892 893 return nbfd; 894} 895 896/* 897FUNCTION 898 bfd_make_writable 899 900SYNOPSIS 901 bool bfd_make_writable (bfd *abfd); 902 903DESCRIPTION 904 Takes a BFD as created by <<bfd_create>> and converts it 905 into one like as returned by <<bfd_openw>>. It does this 906 by converting the BFD to BFD_IN_MEMORY. It's assumed that 907 you will call <<bfd_make_readable>> on this bfd later. 908 909RETURNS 910 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. 911*/ 912 913bool 914bfd_make_writable (bfd *abfd) 915{ 916 struct bfd_in_memory *bim; 917 918 if (abfd->direction != no_direction) 919 { 920 bfd_set_error (bfd_error_invalid_operation); 921 return false; 922 } 923 924 bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory)); 925 if (bim == NULL) 926 return false; /* bfd_error already set. */ 927 abfd->iostream = bim; 928 /* bfd_bwrite will grow these as needed. */ 929 bim->size = 0; 930 bim->buffer = 0; 931 932 abfd->flags |= BFD_IN_MEMORY; 933 abfd->iovec = &_bfd_memory_iovec; 934 abfd->origin = 0; 935 abfd->direction = write_direction; 936 abfd->where = 0; 937 938 return true; 939} 940 941/* 942FUNCTION 943 bfd_make_readable 944 945SYNOPSIS 946 bool bfd_make_readable (bfd *abfd); 947 948DESCRIPTION 949 Takes a BFD as created by <<bfd_create>> and 950 <<bfd_make_writable>> and converts it into one like as 951 returned by <<bfd_openr>>. It does this by writing the 952 contents out to the memory buffer, then reversing the 953 direction. 954 955RETURNS 956 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */ 957 958bool 959bfd_make_readable (bfd *abfd) 960{ 961 if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY)) 962 { 963 bfd_set_error (bfd_error_invalid_operation); 964 return false; 965 } 966 967 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) 968 return false; 969 970 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) 971 return false; 972 973 abfd->arch_info = &bfd_default_arch_struct; 974 975 abfd->where = 0; 976 abfd->format = bfd_unknown; 977 abfd->my_archive = NULL; 978 abfd->origin = 0; 979 abfd->opened_once = false; 980 abfd->output_has_begun = false; 981 abfd->section_count = 0; 982 abfd->usrdata = NULL; 983 abfd->cacheable = false; 984 abfd->flags |= BFD_IN_MEMORY; 985 abfd->mtime_set = false; 986 987 abfd->target_defaulted = true; 988 abfd->direction = read_direction; 989 abfd->sections = 0; 990 abfd->symcount = 0; 991 abfd->outsymbols = 0; 992 abfd->tdata.any = 0; 993 994 bfd_section_list_clear (abfd); 995 bfd_check_format (abfd, bfd_object); 996 997 return true; 998} 999 1000/* 1001FUNCTION 1002 bfd_alloc 1003 1004SYNOPSIS 1005 void *bfd_alloc (bfd *abfd, bfd_size_type wanted); 1006 1007DESCRIPTION 1008 Allocate a block of @var{wanted} bytes of memory attached to 1009 <<abfd>> and return a pointer to it. 1010*/ 1011 1012void * 1013bfd_alloc (bfd *abfd, bfd_size_type size) 1014{ 1015 void *ret; 1016 unsigned long ul_size = (unsigned long) size; 1017 1018 if (size != ul_size 1019 /* Note - although objalloc_alloc takes an unsigned long as its 1020 argument, internally the size is treated as a signed long. This can 1021 lead to problems where, for example, a request to allocate -1 bytes 1022 can result in just 1 byte being allocated, rather than 1023 ((unsigned long) -1) bytes. Also memory checkers will often 1024 complain about attempts to allocate a negative amount of memory. 1025 So to stop these problems we fail if the size is negative. */ 1026 || ((signed long) ul_size) < 0) 1027 { 1028 bfd_set_error (bfd_error_no_memory); 1029 return NULL; 1030 } 1031 1032 ret = objalloc_alloc ((struct objalloc *) abfd->memory, ul_size); 1033 if (ret == NULL) 1034 bfd_set_error (bfd_error_no_memory); 1035 else 1036 abfd->alloc_size += size; 1037 return ret; 1038} 1039 1040/* 1041FUNCTION 1042 bfd_zalloc 1043 1044SYNOPSIS 1045 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted); 1046 1047DESCRIPTION 1048 Allocate a block of @var{wanted} bytes of zeroed memory 1049 attached to <<abfd>> and return a pointer to it. 1050*/ 1051 1052void * 1053bfd_zalloc (bfd *abfd, bfd_size_type size) 1054{ 1055 void *res; 1056 1057 res = bfd_alloc (abfd, size); 1058 if (res) 1059 memset (res, 0, (size_t) size); 1060 return res; 1061} 1062 1063/* Free a block allocated for a BFD. 1064 Note: Also frees all more recently allocated blocks! */ 1065 1066void 1067bfd_release (bfd *abfd, void *block) 1068{ 1069 objalloc_free_block ((struct objalloc *) abfd->memory, block); 1070} 1071 1072 1073/* 1074 GNU Extension: separate debug-info files 1075 1076 The idea here is that a special section called .gnu_debuglink might be 1077 embedded in a binary file, which indicates that some *other* file 1078 contains the real debugging information. This special section contains a 1079 filename and CRC32 checksum, which we read and resolve to another file, 1080 if it exists. 1081 1082 This facilitates "optional" provision of debugging information, without 1083 having to provide two complete copies of every binary object (with and 1084 without debug symbols). */ 1085 1086#define GNU_DEBUGLINK ".gnu_debuglink" 1087#define GNU_DEBUGALTLINK ".gnu_debugaltlink" 1088 1089/* 1090FUNCTION 1091 bfd_calc_gnu_debuglink_crc32 1092 1093SYNOPSIS 1094 unsigned long bfd_calc_gnu_debuglink_crc32 1095 (unsigned long crc, const unsigned char *buf, bfd_size_type len); 1096 1097DESCRIPTION 1098 Computes a CRC value as used in the .gnu_debuglink section. 1099 Advances the previously computed @var{crc} value by computing 1100 and adding in the crc32 for @var{len} bytes of @var{buf}. 1101 1102RETURNS 1103 Return the updated CRC32 value. 1104*/ 1105 1106unsigned long 1107bfd_calc_gnu_debuglink_crc32 (unsigned long crc, 1108 const unsigned char *buf, 1109 bfd_size_type len) 1110{ 1111 static const unsigned long crc32_table[256] = 1112 { 1113 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 1114 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 1115 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 1116 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 1117 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 1118 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 1119 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 1120 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 1121 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 1122 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 1123 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 1124 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 1125 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 1126 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 1127 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 1128 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 1129 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 1130 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 1131 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 1132 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 1133 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 1134 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 1135 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 1136 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 1137 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 1138 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 1139 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 1140 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 1141 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 1142 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 1143 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 1144 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 1145 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 1146 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 1147 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 1148 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 1149 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 1150 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 1151 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 1152 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 1153 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 1154 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 1155 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 1156 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 1157 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 1158 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 1159 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 1160 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 1161 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 1162 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 1163 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 1164 0x2d02ef8d 1165 }; 1166 const unsigned char *end; 1167 1168 crc = ~crc & 0xffffffff; 1169 for (end = buf + len; buf < end; ++ buf) 1170 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8); 1171 return ~crc & 0xffffffff; 1172} 1173 1174 1175/* 1176INTERNAL_FUNCTION 1177 bfd_get_debug_link_info_1 1178 1179SYNOPSIS 1180 char *bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out); 1181 1182DESCRIPTION 1183 Extracts the filename and CRC32 value for any separate debug 1184 information file associated with @var{abfd}. 1185 1186 The @var{crc32_out} parameter is an untyped pointer because 1187 this routine is used as a @code{get_func_type} function, but it 1188 is expected to be an unsigned long pointer. 1189 1190RETURNS 1191 The filename of the associated debug information file, or NULL 1192 if there is no such file. If the filename was found then the 1193 contents of @var{crc32_out} are updated to hold the corresponding 1194 CRC32 value for the file. 1195 1196 The returned filename is allocated with @code{malloc}; freeing 1197 it is the responsibility of the caller. 1198*/ 1199 1200static char * 1201bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out) 1202{ 1203 asection *sect; 1204 unsigned long *crc32 = (unsigned long *) crc32_out; 1205 bfd_byte *contents; 1206 unsigned int crc_offset; 1207 char *name; 1208 bfd_size_type size; 1209 ufile_ptr file_size; 1210 1211 BFD_ASSERT (abfd); 1212 BFD_ASSERT (crc32_out); 1213 1214 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK); 1215 1216 if (sect == NULL) 1217 return NULL; 1218 1219 size = bfd_section_size (sect); 1220 file_size = bfd_get_size (abfd); 1221 1222 /* PR 22794: Make sure that the section has a reasonable size. */ 1223 if (size < 8 || (file_size != 0 && size >= file_size)) 1224 return NULL; 1225 1226 if (!bfd_malloc_and_get_section (abfd, sect, &contents)) 1227 { 1228 free (contents); 1229 return NULL; 1230 } 1231 1232 /* CRC value is stored after the filename, aligned up to 4 bytes. */ 1233 name = (char *) contents; 1234 /* PR 17597: Avoid reading off the end of the buffer. */ 1235 crc_offset = strnlen (name, size) + 1; 1236 crc_offset = (crc_offset + 3) & ~3; 1237 if (crc_offset + 4 > size) 1238 return NULL; 1239 1240 *crc32 = bfd_get_32 (abfd, contents + crc_offset); 1241 return name; 1242} 1243 1244 1245/* 1246FUNCTION 1247 bfd_get_debug_link_info 1248 1249SYNOPSIS 1250 char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out); 1251 1252DESCRIPTION 1253 Extracts the filename and CRC32 value for any separate debug 1254 information file associated with @var{abfd}. 1255 1256RETURNS 1257 The filename of the associated debug information file, or NULL 1258 if there is no such file. If the filename was found then the 1259 contents of @var{crc32_out} are updated to hold the corresponding 1260 CRC32 value for the file. 1261 1262 The returned filename is allocated with @code{malloc}; freeing 1263 it is the responsibility of the caller. 1264*/ 1265 1266char * 1267bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out) 1268{ 1269 return bfd_get_debug_link_info_1 (abfd, crc32_out); 1270} 1271 1272/* 1273FUNCTION 1274 bfd_get_alt_debug_link_info 1275 1276SYNOPSIS 1277 char *bfd_get_alt_debug_link_info (bfd * abfd, 1278 bfd_size_type *buildid_len, 1279 bfd_byte **buildid_out); 1280 1281DESCRIPTION 1282 Fetch the filename and BuildID value for any alternate debuginfo 1283 associated with @var{abfd}. Return NULL if no such info found, 1284 otherwise return filename and update @var{buildid_len} and 1285 @var{buildid_out}. The returned filename and build_id are 1286 allocated with @code{malloc}; freeing them is the responsibility 1287 of the caller. 1288*/ 1289 1290char * 1291bfd_get_alt_debug_link_info (bfd * abfd, bfd_size_type *buildid_len, 1292 bfd_byte **buildid_out) 1293{ 1294 asection *sect; 1295 bfd_byte *contents; 1296 unsigned int buildid_offset; 1297 char *name; 1298 bfd_size_type size; 1299 ufile_ptr file_size; 1300 1301 BFD_ASSERT (abfd); 1302 BFD_ASSERT (buildid_len); 1303 BFD_ASSERT (buildid_out); 1304 1305 sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK); 1306 1307 if (sect == NULL) 1308 return NULL; 1309 1310 size = bfd_section_size (sect); 1311 file_size = bfd_get_size (abfd); 1312 if (size < 8 || (file_size != 0 && size >= file_size)) 1313 return NULL; 1314 1315 if (!bfd_malloc_and_get_section (abfd, sect, & contents)) 1316 { 1317 free (contents); 1318 return NULL; 1319 } 1320 1321 /* BuildID value is stored after the filename. */ 1322 name = (char *) contents; 1323 buildid_offset = strnlen (name, size) + 1; 1324 if (buildid_offset >= bfd_section_size (sect)) 1325 return NULL; 1326 1327 *buildid_len = size - buildid_offset; 1328 *buildid_out = bfd_malloc (*buildid_len); 1329 memcpy (*buildid_out, contents + buildid_offset, *buildid_len); 1330 1331 return name; 1332} 1333 1334/* 1335INTERNAL_FUNCTION 1336 separate_debug_file_exists 1337 1338SYNOPSIS 1339 bool separate_debug_file_exists 1340 (char *name, void *crc32_p); 1341 1342DESCRIPTION 1343 Checks to see if @var{name} is a file and if its contents 1344 match @var{crc32}, which is a pointer to an @code{unsigned 1345 long} containing a CRC32. 1346 1347 The @var{crc32_p} parameter is an untyped pointer because 1348 this routine is used as a @code{check_func_type} function. 1349*/ 1350 1351static bool 1352separate_debug_file_exists (const char *name, void *crc32_p) 1353{ 1354 unsigned char buffer[8 * 1024]; 1355 unsigned long file_crc = 0; 1356 FILE *f; 1357 bfd_size_type count; 1358 unsigned long crc; 1359 1360 BFD_ASSERT (name); 1361 BFD_ASSERT (crc32_p); 1362 1363 crc = *(unsigned long *) crc32_p; 1364 1365 f = _bfd_real_fopen (name, FOPEN_RB); 1366 if (f == NULL) 1367 return false; 1368 1369 while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0) 1370 file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count); 1371 1372 fclose (f); 1373 1374 return crc == file_crc; 1375} 1376 1377/* 1378INTERNAL_FUNCTION 1379 separate_alt_debug_file_exists 1380 1381SYNOPSIS 1382 bool separate_alt_debug_file_exists 1383 (char *name, void *unused); 1384 1385DESCRIPTION 1386 Checks to see if @var{name} is a file. 1387*/ 1388 1389static bool 1390separate_alt_debug_file_exists (const char *name, void *unused ATTRIBUTE_UNUSED) 1391{ 1392 FILE *f; 1393 1394 BFD_ASSERT (name); 1395 1396 f = _bfd_real_fopen (name, FOPEN_RB); 1397 if (f == NULL) 1398 return false; 1399 1400 fclose (f); 1401 1402 return true; 1403} 1404 1405/* 1406INTERNAL_FUNCTION 1407 find_separate_debug_file 1408 1409SYNOPSIS 1410 char *find_separate_debug_file 1411 (bfd *abfd, const char *dir, bool include_dirs, 1412 get_func_type get, check_func_type check, void *data); 1413 1414DESCRIPTION 1415 Searches for a debug information file corresponding to @var{abfd}. 1416 1417 The name of the separate debug info file is returned by the 1418 @var{get} function. This function scans various fixed locations 1419 in the filesystem, including the file tree rooted at @var{dir}. 1420 If the @var{include_dirs} parameter is true then the directory 1421 components of @var{abfd}'s filename will be included in the 1422 searched locations. 1423 1424 @var{data} is passed unmodified to the @var{get} and @var{check} 1425 functions. It is generally used to implement build-id-like 1426 matching in the callback functions. 1427 1428RETURNS 1429 Returns the filename of the first file to be found which 1430 receives a TRUE result from the @var{check} function. 1431 Returns NULL if no valid file could be found. 1432*/ 1433 1434typedef char * (*get_func_type) (bfd *, void *); 1435typedef bool (*check_func_type) (const char *, void *); 1436 1437static char * 1438find_separate_debug_file (bfd *abfd, 1439 const char *debug_file_directory, 1440 bool include_dirs, 1441 get_func_type get_func, 1442 check_func_type check_func, 1443 void *func_data) 1444{ 1445 char *base; 1446 char *dir; 1447 char *debugfile; 1448 char *canon_dir; 1449 size_t dirlen; 1450 size_t canon_dirlen; 1451 1452 BFD_ASSERT (abfd); 1453 if (debug_file_directory == NULL) 1454 debug_file_directory = "."; 1455 1456 /* BFD may have been opened from a stream. */ 1457 if (bfd_get_filename (abfd) == NULL) 1458 { 1459 bfd_set_error (bfd_error_invalid_operation); 1460 return NULL; 1461 } 1462 1463 base = get_func (abfd, func_data); 1464 1465 if (base == NULL) 1466 return NULL; 1467 1468 if (base[0] == '\0') 1469 { 1470 free (base); 1471 bfd_set_error (bfd_error_no_debug_section); 1472 return NULL; 1473 } 1474 1475 if (include_dirs) 1476 { 1477 const char *fname = bfd_get_filename (abfd); 1478 for (dirlen = strlen (fname); dirlen > 0; dirlen--) 1479 if (IS_DIR_SEPARATOR (fname[dirlen - 1])) 1480 break; 1481 1482 dir = (char *) bfd_malloc (dirlen + 1); 1483 if (dir == NULL) 1484 { 1485 free (base); 1486 return NULL; 1487 } 1488 memcpy (dir, fname, dirlen); 1489 dir[dirlen] = '\0'; 1490 } 1491 else 1492 { 1493 dir = (char *) bfd_malloc (1); 1494 * dir = 0; 1495 dirlen = 0; 1496 } 1497 1498 /* Compute the canonical name of the bfd object with all symbolic links 1499 resolved, for use in the global debugfile directory. */ 1500 canon_dir = lrealpath (bfd_get_filename (abfd)); 1501 for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--) 1502 if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1])) 1503 break; 1504 canon_dir[canon_dirlen] = '\0'; 1505 1506#ifndef EXTRA_DEBUG_ROOT1 1507#define EXTRA_DEBUG_ROOT1 "/usr/lib/debug" 1508#endif 1509#ifndef EXTRA_DEBUG_ROOT2 1510#define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr" 1511#endif 1512 1513 debugfile = (char *) 1514 bfd_malloc (strlen (debug_file_directory) + 1 1515 + (canon_dirlen > dirlen ? canon_dirlen : dirlen) 1516 + strlen (".debug/") 1517#ifdef EXTRA_DEBUG_ROOT1 1518 + strlen (EXTRA_DEBUG_ROOT1) 1519#endif 1520#ifdef EXTRA_DEBUG_ROOT2 1521 + strlen (EXTRA_DEBUG_ROOT2) 1522#endif 1523 + strlen (base) 1524 + 1); 1525 if (debugfile == NULL) 1526 goto found; /* Actually this returns NULL. */ 1527 1528 /* First try in the same directory as the original file. 1529 1530 FIXME: Strictly speaking if we are using the build-id method, 1531 (ie include_dirs == FALSE) then we should only check absolute 1532 paths, not relative ones like this one (and the next one). 1533 The check is left in however as this allows the binutils 1534 testsuite to exercise this feature without having to install 1535 a file into the root filesystem. (See binutils/testsuite/ 1536 binutils-all/objdump.exp for the test). */ 1537 sprintf (debugfile, "%s%s", dir, base); 1538 if (check_func (debugfile, func_data)) 1539 goto found; 1540 1541 /* Then try in a subdirectory called .debug. */ 1542 sprintf (debugfile, "%s.debug/%s", dir, base); 1543 if (check_func (debugfile, func_data)) 1544 goto found; 1545 1546#ifdef EXTRA_DEBUG_ROOT1 1547 /* Try the first extra debug file root. */ 1548 sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT1, 1549 include_dirs ? canon_dir : "/", base); 1550 if (check_func (debugfile, func_data)) 1551 goto found; 1552#endif 1553 1554#ifdef EXTRA_DEBUG_ROOT2 1555 /* Try the second extra debug file root. */ 1556 sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT2, 1557 include_dirs ? canon_dir : "/", base); 1558 if (check_func (debugfile, func_data)) 1559 goto found; 1560#endif 1561 1562 /* Then try in the global debugfile directory. */ 1563 strcpy (debugfile, debug_file_directory); 1564 dirlen = strlen (debug_file_directory) - 1; 1565 if (include_dirs) 1566 { 1567 if (dirlen > 0 1568 && debug_file_directory[dirlen] != '/' 1569 && canon_dir[0] != '/') 1570 strcat (debugfile, "/"); 1571 strcat (debugfile, canon_dir); 1572 } 1573 else 1574 { 1575 if (dirlen > 0 && debug_file_directory[dirlen] != '/') 1576 strcat (debugfile, "/"); 1577 } 1578 strcat (debugfile, base); 1579 1580 if (check_func (debugfile, func_data)) 1581 goto found; 1582 1583 /* Failed to find the file. */ 1584 free (debugfile); 1585 debugfile = NULL; 1586 1587 found: 1588 free (base); 1589 free (dir); 1590 free (canon_dir); 1591 return debugfile; 1592} 1593 1594/* 1595FUNCTION 1596 bfd_follow_gnu_debuglink 1597 1598SYNOPSIS 1599 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir); 1600 1601DESCRIPTION 1602 Takes a BFD and searches it for a .gnu_debuglink section. If this 1603 section is found, it examines the section for the name and checksum 1604 of a '.debug' file containing auxiliary debugging information. It 1605 then searches the filesystem for this .debug file in some standard 1606 locations, including the directory tree rooted at @var{dir}, and if 1607 found returns the full filename. 1608 1609 If @var{dir} is NULL, the search will take place starting at 1610 the current directory. 1611 1612RETURNS 1613 <<NULL>> on any errors or failure to locate the .debug file, 1614 otherwise a pointer to a heap-allocated string containing the 1615 filename. The caller is responsible for freeing this string. 1616*/ 1617 1618char * 1619bfd_follow_gnu_debuglink (bfd *abfd, const char *dir) 1620{ 1621 unsigned long crc32; 1622 1623 return find_separate_debug_file (abfd, dir, true, 1624 bfd_get_debug_link_info_1, 1625 separate_debug_file_exists, &crc32); 1626} 1627 1628/* Helper for bfd_follow_gnu_debugaltlink. It just returns the name 1629 of the separate debug file. */ 1630 1631static char * 1632get_alt_debug_link_info_shim (bfd * abfd, void *unused ATTRIBUTE_UNUSED) 1633{ 1634 bfd_size_type len; 1635 bfd_byte *buildid = NULL; 1636 char *result = bfd_get_alt_debug_link_info (abfd, &len, &buildid); 1637 1638 free (buildid); 1639 1640 return result; 1641} 1642 1643/* 1644FUNCTION 1645 bfd_follow_gnu_debugaltlink 1646 1647SYNOPSIS 1648 char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir); 1649 1650DESCRIPTION 1651 Takes a BFD and searches it for a .gnu_debugaltlink section. If this 1652 section is found, it examines the section for the name of a file 1653 containing auxiliary debugging information. It then searches the 1654 filesystem for this file in a set of standard locations, including 1655 the directory tree rooted at @var{dir}, and if found returns the 1656 full filename. 1657 1658 If @var{dir} is NULL, the search will take place starting at 1659 the current directory. 1660 1661RETURNS 1662 <<NULL>> on any errors or failure to locate the debug file, 1663 otherwise a pointer to a heap-allocated string containing the 1664 filename. The caller is responsible for freeing this string. 1665*/ 1666 1667char * 1668bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir) 1669{ 1670 return find_separate_debug_file (abfd, dir, true, 1671 get_alt_debug_link_info_shim, 1672 separate_alt_debug_file_exists, 1673 NULL); 1674} 1675 1676/* 1677FUNCTION 1678 bfd_create_gnu_debuglink_section 1679 1680SYNOPSIS 1681 struct bfd_section *bfd_create_gnu_debuglink_section 1682 (bfd *abfd, const char *filename); 1683 1684DESCRIPTION 1685 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The 1686 section is sized to be big enough to contain a link to the specified 1687 @var{filename}. 1688 1689RETURNS 1690 A pointer to the new section is returned if all is ok. Otherwise 1691 <<NULL>> is returned and bfd_error is set. 1692*/ 1693 1694asection * 1695bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename) 1696{ 1697 asection *sect; 1698 bfd_size_type debuglink_size; 1699 flagword flags; 1700 1701 if (abfd == NULL || filename == NULL) 1702 { 1703 bfd_set_error (bfd_error_invalid_operation); 1704 return NULL; 1705 } 1706 1707 /* Strip off any path components in filename. */ 1708 filename = lbasename (filename); 1709 1710 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK); 1711 if (sect) 1712 { 1713 /* Section already exists. */ 1714 bfd_set_error (bfd_error_invalid_operation); 1715 return NULL; 1716 } 1717 1718 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING; 1719 sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags); 1720 if (sect == NULL) 1721 return NULL; 1722 1723 /* Compute the size of the section. Allow for the CRC after the filename, 1724 and padding so that it will start on a 4-byte boundary. */ 1725 debuglink_size = strlen (filename) + 1; 1726 debuglink_size += 3; 1727 debuglink_size &= ~3; 1728 debuglink_size += 4; 1729 1730 if (!bfd_set_section_size (sect, debuglink_size)) 1731 /* XXX Should we delete the section from the bfd ? */ 1732 return NULL; 1733 1734 /* PR 21193: Ensure that the section has 4-byte alignment for the CRC. 1735 Note - despite the name of the function being called, we are 1736 setting an alignment power, not a byte alignment value. */ 1737 bfd_set_section_alignment (sect, 2); 1738 1739 return sect; 1740} 1741 1742 1743/* 1744FUNCTION 1745 bfd_fill_in_gnu_debuglink_section 1746 1747SYNOPSIS 1748 bool bfd_fill_in_gnu_debuglink_section 1749 (bfd *abfd, struct bfd_section *sect, const char *filename); 1750 1751DESCRIPTION 1752 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT} 1753 and fills in the contents of the section to contain a link to the 1754 specified @var{filename}. The filename should be relative to the 1755 current directory. 1756 1757RETURNS 1758 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned 1759 and bfd_error is set. 1760*/ 1761 1762bool 1763bfd_fill_in_gnu_debuglink_section (bfd *abfd, 1764 struct bfd_section *sect, 1765 const char *filename) 1766{ 1767 bfd_size_type debuglink_size; 1768 unsigned long crc32; 1769 char * contents; 1770 bfd_size_type crc_offset; 1771 FILE * handle; 1772 unsigned char buffer[8 * 1024]; 1773 size_t count; 1774 size_t filelen; 1775 1776 if (abfd == NULL || sect == NULL || filename == NULL) 1777 { 1778 bfd_set_error (bfd_error_invalid_operation); 1779 return false; 1780 } 1781 1782 /* Make sure that we can read the file. 1783 XXX - Should we attempt to locate the debug info file using the same 1784 algorithm as gdb ? At the moment, since we are creating the 1785 .gnu_debuglink section, we insist upon the user providing us with a 1786 correct-for-section-creation-time path, but this need not conform to 1787 the gdb location algorithm. */ 1788 handle = _bfd_real_fopen (filename, FOPEN_RB); 1789 if (handle == NULL) 1790 { 1791 bfd_set_error (bfd_error_system_call); 1792 return false; 1793 } 1794 1795 crc32 = 0; 1796 while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0) 1797 crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count); 1798 fclose (handle); 1799 1800 /* Strip off any path components in filename, 1801 now that we no longer need them. */ 1802 filename = lbasename (filename); 1803 1804 filelen = strlen (filename); 1805 debuglink_size = filelen + 1; 1806 debuglink_size += 3; 1807 debuglink_size &= ~3; 1808 debuglink_size += 4; 1809 1810 contents = (char *) bfd_malloc (debuglink_size); 1811 if (contents == NULL) 1812 { 1813 /* XXX Should we delete the section from the bfd ? */ 1814 return false; 1815 } 1816 1817 crc_offset = debuglink_size - 4; 1818 memcpy (contents, filename, filelen); 1819 memset (contents + filelen, 0, crc_offset - filelen); 1820 1821 bfd_put_32 (abfd, crc32, contents + crc_offset); 1822 1823 if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size)) 1824 { 1825 /* XXX Should we delete the section from the bfd ? */ 1826 free (contents); 1827 return false; 1828 } 1829 1830 return true; 1831} 1832 1833/* 1834INTERNAL_FUNCTION 1835 get_build_id 1836 1837SYNOPSIS 1838 struct bfd_build_id * get_build_id (bfd *abfd); 1839 1840DESCRIPTION 1841 Finds the build-id associated with @var{abfd}. If the build-id is 1842 extracted from the note section then a build-id structure is built 1843 for it, using memory allocated to @var{abfd}, and this is then 1844 attached to the @var{abfd}. 1845 1846RETURNS 1847 Returns a pointer to the build-id structure if a build-id could be 1848 found. If no build-id is found NULL is returned and error code is 1849 set. 1850*/ 1851 1852static struct bfd_build_id * 1853get_build_id (bfd *abfd) 1854{ 1855 struct bfd_build_id *build_id; 1856 Elf_Internal_Note inote; 1857 Elf_External_Note *enote; 1858 bfd_byte *contents; 1859 asection *sect; 1860 bfd_size_type size; 1861 1862 BFD_ASSERT (abfd); 1863 1864 if (abfd->build_id && abfd->build_id->size > 0) 1865 /* Save some time by using the already computed build-id. */ 1866 return (struct bfd_build_id *) abfd->build_id; 1867 1868 sect = bfd_get_section_by_name (abfd, ".note.gnu.build-id"); 1869 if (sect == NULL) 1870 { 1871 bfd_set_error (bfd_error_no_debug_section); 1872 return NULL; 1873 } 1874 1875 size = bfd_section_size (sect); 1876 /* FIXME: Should we support smaller build-id notes ? */ 1877 if (size < 0x24) 1878 { 1879 bfd_set_error (bfd_error_invalid_operation); 1880 return NULL; 1881 } 1882 1883 if (!bfd_malloc_and_get_section (abfd, sect, & contents)) 1884 { 1885 free (contents); 1886 return NULL; 1887 } 1888 1889 /* FIXME: Paranoia - allow for compressed build-id sections. 1890 Maybe we should complain if this size is different from 1891 the one obtained above... */ 1892 size = bfd_section_size (sect); 1893 if (size < sizeof (Elf_External_Note)) 1894 { 1895 bfd_set_error (bfd_error_invalid_operation); 1896 free (contents); 1897 return NULL; 1898 } 1899 1900 enote = (Elf_External_Note *) contents; 1901 inote.type = H_GET_32 (abfd, enote->type); 1902 inote.namesz = H_GET_32 (abfd, enote->namesz); 1903 inote.namedata = enote->name; 1904 inote.descsz = H_GET_32 (abfd, enote->descsz); 1905 inote.descdata = inote.namedata + BFD_ALIGN (inote.namesz, 4); 1906 /* FIXME: Should we check for extra notes in this section ? */ 1907 1908 if (inote.descsz <= 0 1909 || inote.type != NT_GNU_BUILD_ID 1910 || inote.namesz != 4 /* sizeof "GNU" */ 1911 || !startswith (inote.namedata, "GNU") 1912 || inote.descsz > 0x7ffffffe 1913 || size < (12 + BFD_ALIGN (inote.namesz, 4) + inote.descsz)) 1914 { 1915 free (contents); 1916 bfd_set_error (bfd_error_invalid_operation); 1917 return NULL; 1918 } 1919 1920 build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) + inote.descsz); 1921 if (build_id == NULL) 1922 { 1923 free (contents); 1924 return NULL; 1925 } 1926 1927 build_id->size = inote.descsz; 1928 memcpy (build_id->data, inote.descdata, inote.descsz); 1929 abfd->build_id = build_id; 1930 free (contents); 1931 1932 return build_id; 1933} 1934 1935/* 1936INTERNAL_FUNCTION 1937 get_build_id_name 1938 1939SYNOPSIS 1940 char * get_build_id_name (bfd *abfd, void *build_id_out_p) 1941 1942DESCRIPTION 1943 Searches @var{abfd} for a build-id, and then constructs a pathname 1944 from it. The path is computed as .build-id/NN/NN+NN.debug where 1945 NNNN+NN is the build-id value as a hexadecimal string. 1946 1947RETURNS 1948 Returns the constructed filename or NULL upon error. 1949 It is the caller's responsibility to free the memory used to hold the 1950 filename. 1951 If a filename is returned then the @var{build_id_out_p} 1952 parameter (which points to a @code{struct bfd_build_id} 1953 pointer) is set to a pointer to the build_id structure. 1954*/ 1955 1956static char * 1957get_build_id_name (bfd *abfd, void *build_id_out_p) 1958{ 1959 struct bfd_build_id **build_id_out = build_id_out_p; 1960 struct bfd_build_id *build_id; 1961 char *name; 1962 char *n; 1963 bfd_size_type s; 1964 bfd_byte *d; 1965 1966 if (abfd == NULL || bfd_get_filename (abfd) == NULL || build_id_out == NULL) 1967 { 1968 bfd_set_error (bfd_error_invalid_operation); 1969 return NULL; 1970 } 1971 1972 build_id = get_build_id (abfd); 1973 if (build_id == NULL) 1974 return NULL; 1975 1976 /* Compute the debug pathname corresponding to the build-id. */ 1977 name = bfd_malloc (strlen (".build-id/") + build_id->size * 2 + 2 + strlen (".debug")); 1978 if (name == NULL) 1979 { 1980 bfd_set_error (bfd_error_no_memory); 1981 return NULL; 1982 } 1983 n = name; 1984 d = build_id->data; 1985 s = build_id->size; 1986 1987 n += sprintf (n, ".build-id/"); 1988 n += sprintf (n, "%02x", (unsigned) *d++); s--; 1989 n += sprintf (n, "/"); 1990 while (s--) 1991 n += sprintf (n, "%02x", (unsigned) *d++); 1992 n += sprintf (n, ".debug"); 1993 1994 *build_id_out = build_id; 1995 return name; 1996} 1997 1998/* 1999INTERNAL_FUNCTION 2000 check_build_id_file 2001 2002SYNOPSIS 2003 bool check_build_id_file (char *name, void *buildid_p); 2004 2005DESCRIPTION 2006 Checks to see if @var{name} is a readable file and if its build-id 2007 matches @var{buildid}. 2008 2009RETURNS 2010 Returns TRUE if the file exists, is readable, and contains a 2011 build-id which matches the build-id pointed at by 2012 @var{build_id_p} (which is really a @code{struct bfd_build_id **}). 2013*/ 2014 2015static bool 2016check_build_id_file (const char *name, void *buildid_p) 2017{ 2018 struct bfd_build_id *orig_build_id; 2019 struct bfd_build_id *build_id; 2020 bfd * file; 2021 bool result; 2022 2023 BFD_ASSERT (name); 2024 BFD_ASSERT (buildid_p); 2025 2026 file = bfd_openr (name, NULL); 2027 if (file == NULL) 2028 return false; 2029 2030 /* If the file is an archive, process all of its elements. */ 2031 if (! bfd_check_format (file, bfd_object)) 2032 { 2033 bfd_close (file); 2034 return false; 2035 } 2036 2037 build_id = get_build_id (file); 2038 if (build_id == NULL) 2039 { 2040 bfd_close (file); 2041 return false; 2042 } 2043 2044 orig_build_id = *(struct bfd_build_id **) buildid_p; 2045 2046 result = build_id->size == orig_build_id->size 2047 && memcmp (build_id->data, orig_build_id->data, build_id->size) == 0; 2048 2049 (void) bfd_close (file); 2050 2051 return result; 2052} 2053 2054/* 2055FUNCTION 2056 bfd_follow_build_id_debuglink 2057 2058SYNOPSIS 2059 char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir); 2060 2061DESCRIPTION 2062 Takes @var{abfd} and searches it for a .note.gnu.build-id section. 2063 If this section is found, it extracts the value of the NT_GNU_BUILD_ID 2064 note, which should be a hexadecimal value @var{NNNN+NN} (for 2065 32+ hex digits). It then searches the filesystem for a file named 2066 @var{.build-id/NN/NN+NN.debug} in a set of standard locations, 2067 including the directory tree rooted at @var{dir}. The filename 2068 of the first matching file to be found is returned. A matching 2069 file should contain a .note.gnu.build-id section with the same 2070 @var{NNNN+NN} note as @var{abfd}, although this check is currently 2071 not implemented. 2072 2073 If @var{dir} is NULL, the search will take place starting at 2074 the current directory. 2075 2076RETURNS 2077 <<NULL>> on any errors or failure to locate the debug file, 2078 otherwise a pointer to a heap-allocated string containing the 2079 filename. The caller is responsible for freeing this string. 2080*/ 2081 2082char * 2083bfd_follow_build_id_debuglink (bfd *abfd, const char *dir) 2084{ 2085 struct bfd_build_id *build_id; 2086 2087 return find_separate_debug_file (abfd, dir, false, 2088 get_build_id_name, 2089 check_build_id_file, &build_id); 2090} 2091 2092/* 2093FUNCTION 2094 bfd_set_filename 2095 2096SYNOPSIS 2097 const char *bfd_set_filename (bfd *abfd, const char *filename); 2098 2099DESCRIPTION 2100 Set the filename of @var{abfd}, copying the FILENAME parameter to 2101 bfd_alloc'd memory owned by @var{abfd}. Returns a pointer the 2102 newly allocated name, or NULL if the allocation failed. 2103*/ 2104 2105const char * 2106bfd_set_filename (bfd *abfd, const char *filename) 2107{ 2108 size_t len = strlen (filename) + 1; 2109 char *n = bfd_alloc (abfd, len); 2110 2111 if (n == NULL) 2112 return NULL; 2113 2114 if (abfd->filename != NULL) 2115 { 2116 /* PR 29389. If we attempt to rename a file that has been closed due 2117 to caching, then we will not be able to reopen it later on. */ 2118 if (abfd->iostream == NULL && (abfd->flags & BFD_CLOSED_BY_CACHE)) 2119 { 2120 bfd_set_error (bfd_error_invalid_operation); 2121 return NULL; 2122 } 2123 2124 /* Similarly if we attempt to close a renamed file because the 2125 cache is now full, we will not be able to reopen it later on. */ 2126 if (abfd->iostream != NULL) 2127 abfd->cacheable = 0; 2128 } 2129 2130 memcpy (n, filename, len); 2131 abfd->filename = n; 2132 2133 return n; 2134} 2135