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