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