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