libbfd.c revision 77298
1/* Assorted BFD support routines, only used internally. 2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999 3 Free Software Foundation, Inc. 4 Written by Cygnus Support. 5 6This file is part of BFD, the Binary File Descriptor library. 7 8This program is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2 of the License, or 11(at your option) any later version. 12 13This program is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with this program; if not, write to the Free Software 20Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 21 22#include "bfd.h" 23#include "sysdep.h" 24#include "libbfd.h" 25 26#ifndef HAVE_GETPAGESIZE 27#define getpagesize() 2048 28#endif 29 30static int real_read PARAMS ((PTR, size_t, size_t, FILE *)); 31 32/* 33SECTION 34 Internal functions 35 36DESCRIPTION 37 These routines are used within BFD. 38 They are not intended for export, but are documented here for 39 completeness. 40*/ 41 42/* A routine which is used in target vectors for unsupported 43 operations. */ 44 45boolean 46bfd_false (ignore) 47 bfd *ignore ATTRIBUTE_UNUSED; 48{ 49 bfd_set_error (bfd_error_invalid_operation); 50 return false; 51} 52 53/* A routine which is used in target vectors for supported operations 54 which do not actually do anything. */ 55 56boolean 57bfd_true (ignore) 58 bfd *ignore ATTRIBUTE_UNUSED; 59{ 60 return true; 61} 62 63/* A routine which is used in target vectors for unsupported 64 operations which return a pointer value. */ 65 66PTR 67bfd_nullvoidptr (ignore) 68 bfd *ignore ATTRIBUTE_UNUSED; 69{ 70 bfd_set_error (bfd_error_invalid_operation); 71 return NULL; 72} 73 74int 75bfd_0 (ignore) 76 bfd *ignore ATTRIBUTE_UNUSED; 77{ 78 return 0; 79} 80 81unsigned int 82bfd_0u (ignore) 83 bfd *ignore ATTRIBUTE_UNUSED; 84{ 85 return 0; 86} 87 88long 89bfd_0l (ignore) 90 bfd *ignore ATTRIBUTE_UNUSED; 91{ 92 return 0; 93} 94 95/* A routine which is used in target vectors for unsupported 96 operations which return -1 on error. */ 97 98long 99_bfd_n1 (ignore_abfd) 100 bfd *ignore_abfd ATTRIBUTE_UNUSED; 101{ 102 bfd_set_error (bfd_error_invalid_operation); 103 return -1; 104} 105 106void 107bfd_void (ignore) 108 bfd *ignore ATTRIBUTE_UNUSED; 109{ 110} 111 112boolean 113_bfd_nocore_core_file_matches_executable_p (ignore_core_bfd, ignore_exec_bfd) 114 bfd *ignore_core_bfd ATTRIBUTE_UNUSED; 115 bfd *ignore_exec_bfd ATTRIBUTE_UNUSED; 116{ 117 bfd_set_error (bfd_error_invalid_operation); 118 return false; 119} 120 121/* Routine to handle core_file_failing_command entry point for targets 122 without core file support. */ 123 124char * 125_bfd_nocore_core_file_failing_command (ignore_abfd) 126 bfd *ignore_abfd ATTRIBUTE_UNUSED; 127{ 128 bfd_set_error (bfd_error_invalid_operation); 129 return (char *)NULL; 130} 131 132/* Routine to handle core_file_failing_signal entry point for targets 133 without core file support. */ 134 135int 136_bfd_nocore_core_file_failing_signal (ignore_abfd) 137 bfd *ignore_abfd ATTRIBUTE_UNUSED; 138{ 139 bfd_set_error (bfd_error_invalid_operation); 140 return 0; 141} 142 143const bfd_target * 144_bfd_dummy_target (ignore_abfd) 145 bfd *ignore_abfd ATTRIBUTE_UNUSED; 146{ 147 bfd_set_error (bfd_error_wrong_format); 148 return 0; 149} 150 151/* Allocate memory using malloc. */ 152 153PTR 154bfd_malloc (size) 155 size_t size; 156{ 157 PTR ptr; 158 159 ptr = (PTR) malloc (size); 160 if (ptr == NULL && size != 0) 161 bfd_set_error (bfd_error_no_memory); 162 return ptr; 163} 164 165/* Reallocate memory using realloc. */ 166 167PTR 168bfd_realloc (ptr, size) 169 PTR ptr; 170 size_t size; 171{ 172 PTR ret; 173 174 if (ptr == NULL) 175 ret = malloc (size); 176 else 177 ret = realloc (ptr, size); 178 179 if (ret == NULL) 180 bfd_set_error (bfd_error_no_memory); 181 182 return ret; 183} 184 185/* Allocate memory using malloc and clear it. */ 186 187PTR 188bfd_zmalloc (size) 189 size_t size; 190{ 191 PTR ptr; 192 193 ptr = (PTR) malloc (size); 194 195 if (size != 0) 196 { 197 if (ptr == NULL) 198 bfd_set_error (bfd_error_no_memory); 199 else 200 memset (ptr, 0, size); 201 } 202 203 return ptr; 204} 205 206/* Some IO code */ 207 208/* Note that archive entries don't have streams; they share their parent's. 209 This allows someone to play with the iostream behind BFD's back. 210 211 Also, note that the origin pointer points to the beginning of a file's 212 contents (0 for non-archive elements). For archive entries this is the 213 first octet in the file, NOT the beginning of the archive header. */ 214 215static int 216real_read (where, a,b, file) 217 PTR where; 218 size_t a; 219 size_t b; 220 FILE *file; 221{ 222 /* FIXME - this looks like an optimization, but it's really to cover 223 up for a feature of some OSs (not solaris - sigh) that 224 ld/pe-dll.c takes advantage of (apparently) when it creates BFDs 225 internally and tries to link against them. BFD seems to be smart 226 enough to realize there are no symbol records in the "file" that 227 doesn't exist but attempts to read them anyway. On Solaris, 228 attempting to read zero bytes from a NULL file results in a core 229 dump, but on other platforms it just returns zero bytes read. 230 This makes it to something reasonable. - DJ */ 231 if (a == 0 || b == 0) 232 return 0; 233 234#if defined (__VAX) && defined (VMS) 235 /* Apparently fread on Vax VMS does not keep the record length 236 information. */ 237 return read (fileno (file), where, a * b); 238#else 239 return fread (where, a, b, file); 240#endif 241} 242 243/* Return value is amount read (FIXME: how are errors and end of file dealt 244 with? We never call bfd_set_error, which is probably a mistake). */ 245 246bfd_size_type 247bfd_read (ptr, size, nitems, abfd) 248 PTR ptr; 249 bfd_size_type size; 250 bfd_size_type nitems; 251 bfd *abfd; 252{ 253 int nread; 254 255 if ((abfd->flags & BFD_IN_MEMORY) != 0) 256 { 257 struct bfd_in_memory *bim; 258 bfd_size_type get; 259 260 bim = (struct bfd_in_memory *) abfd->iostream; 261 get = size * nitems; 262 if (abfd->where + get > bim->size) 263 { 264 if (bim->size < (bfd_size_type) abfd->where) 265 get = 0; 266 else 267 get = bim->size - abfd->where; 268 bfd_set_error (bfd_error_file_truncated); 269 } 270 memcpy (ptr, bim->buffer + abfd->where, get); 271 abfd->where += get; 272 return get; 273 } 274 275 nread = real_read (ptr, 1, (size_t) (size*nitems), bfd_cache_lookup(abfd)); 276 if (nread > 0) 277 abfd->where += nread; 278 279 /* Set bfd_error if we did not read as much data as we expected. 280 281 If the read failed due to an error set the bfd_error_system_call, 282 else set bfd_error_file_truncated. 283 284 A BFD backend may wish to override bfd_error_file_truncated to 285 provide something more useful (eg. no_symbols or wrong_format). */ 286 if (nread != (int) (size * nitems)) 287 { 288 if (ferror (bfd_cache_lookup (abfd))) 289 bfd_set_error (bfd_error_system_call); 290 else 291 bfd_set_error (bfd_error_file_truncated); 292 } 293 294 return nread; 295} 296 297/* The window support stuff should probably be broken out into 298 another file.... */ 299/* The idea behind the next and refcount fields is that one mapped 300 region can suffice for multiple read-only windows or multiple 301 non-overlapping read-write windows. It's not implemented yet 302 though. */ 303struct _bfd_window_internal { 304 struct _bfd_window_internal *next; 305 PTR data; 306 bfd_size_type size; 307 int refcount : 31; /* should be enough... */ 308 unsigned mapped : 1; /* 1 = mmap, 0 = malloc */ 309}; 310 311void 312bfd_init_window (windowp) 313 bfd_window *windowp; 314{ 315 windowp->data = 0; 316 windowp->i = 0; 317 windowp->size = 0; 318} 319 320/* Currently, if USE_MMAP is undefined, none if the window stuff is 321 used. Okay, so it's mis-named. At least the command-line option 322 "--without-mmap" is more obvious than "--without-windows" or some 323 such. */ 324#ifdef USE_MMAP 325 326#undef HAVE_MPROTECT /* code's not tested yet */ 327 328#if HAVE_MMAP || HAVE_MPROTECT || HAVE_MADVISE 329#include <sys/mman.h> 330#endif 331 332#ifndef MAP_FILE 333#define MAP_FILE 0 334#endif 335 336static int debug_windows; 337 338void 339bfd_free_window (windowp) 340 bfd_window *windowp; 341{ 342 bfd_window_internal *i = windowp->i; 343 windowp->i = 0; 344 windowp->data = 0; 345 if (i == 0) 346 return; 347 i->refcount--; 348 if (debug_windows) 349 fprintf (stderr, "freeing window @%p<%p,%lx,%p>\n", 350 windowp, windowp->data, windowp->size, windowp->i); 351 if (i->refcount != 0) 352 return; 353 354 if (i->mapped) 355 { 356#ifdef HAVE_MMAP 357 munmap (i->data, i->size); 358 goto no_free; 359#else 360 abort (); 361#endif 362 } 363#ifdef HAVE_MPROTECT 364 mprotect (i->data, i->size, PROT_READ | PROT_WRITE); 365#endif 366 free (i->data); 367#ifdef HAVE_MMAP 368 no_free: 369#endif 370 i->data = 0; 371 /* There should be no more references to i at this point. */ 372 free (i); 373} 374 375static int ok_to_map = 1; 376 377boolean 378bfd_get_file_window (abfd, offset, size, windowp, writable) 379 bfd *abfd; 380 file_ptr offset; 381 bfd_size_type size; 382 bfd_window *windowp; 383 boolean writable; 384{ 385 static size_t pagesize; 386 bfd_window_internal *i = windowp->i; 387 size_t size_to_alloc = size; 388 389 if (debug_windows) 390 fprintf (stderr, "bfd_get_file_window (%p, %6ld, %6ld, %p<%p,%lx,%p>, %d)", 391 abfd, (long) offset, (long) size, 392 windowp, windowp->data, (unsigned long) windowp->size, 393 windowp->i, writable); 394 395 /* Make sure we know the page size, so we can be friendly to mmap. */ 396 if (pagesize == 0) 397 pagesize = getpagesize (); 398 if (pagesize == 0) 399 abort (); 400 401 if (i == 0) 402 { 403 windowp->i = i = (bfd_window_internal *) bfd_zmalloc (sizeof (bfd_window_internal)); 404 if (i == 0) 405 return false; 406 i->data = 0; 407 } 408#ifdef HAVE_MMAP 409 if (ok_to_map 410 && (i->data == 0 || i->mapped == 1) 411 && (abfd->flags & BFD_IN_MEMORY) == 0) 412 { 413 file_ptr file_offset, offset2; 414 size_t real_size; 415 int fd; 416 FILE *f; 417 418 /* Find the real file and the real offset into it. */ 419 while (abfd->my_archive != NULL) 420 { 421 offset += abfd->origin; 422 abfd = abfd->my_archive; 423 } 424 f = bfd_cache_lookup (abfd); 425 fd = fileno (f); 426 427 /* Compute offsets and size for mmap and for the user's data. */ 428 offset2 = offset % pagesize; 429 if (offset2 < 0) 430 abort (); 431 file_offset = offset - offset2; 432 real_size = offset + size - file_offset; 433 real_size = real_size + pagesize - 1; 434 real_size -= real_size % pagesize; 435 436 /* If we're re-using a memory region, make sure it's big enough. */ 437 if (i->data && i->size < size) 438 { 439 munmap (i->data, i->size); 440 i->data = 0; 441 } 442 i->data = mmap (i->data, real_size, 443 writable ? PROT_WRITE | PROT_READ : PROT_READ, 444 (writable 445 ? MAP_FILE | MAP_PRIVATE 446 : MAP_FILE | MAP_SHARED), 447 fd, file_offset); 448 if (i->data == (PTR) -1) 449 { 450 /* An error happened. Report it, or try using malloc, or 451 something. */ 452 bfd_set_error (bfd_error_system_call); 453 i->data = 0; 454 windowp->data = 0; 455 if (debug_windows) 456 fprintf (stderr, "\t\tmmap failed!\n"); 457 return false; 458 } 459 if (debug_windows) 460 fprintf (stderr, "\n\tmapped %ld at %p, offset is %ld\n", 461 (long) real_size, i->data, (long) offset2); 462 i->size = real_size; 463 windowp->data = (PTR) ((bfd_byte *) i->data + offset2); 464 windowp->size = size; 465 i->mapped = 1; 466 return true; 467 } 468 else if (debug_windows) 469 { 470 if (ok_to_map) 471 fprintf (stderr, _("not mapping: data=%lx mapped=%d\n"), 472 (unsigned long) i->data, (int) i->mapped); 473 else 474 fprintf (stderr, _("not mapping: env var not set\n")); 475 } 476#else 477 ok_to_map = 0; 478#endif 479 480#ifdef HAVE_MPROTECT 481 if (!writable) 482 { 483 size_to_alloc += pagesize - 1; 484 size_to_alloc -= size_to_alloc % pagesize; 485 } 486#endif 487 if (debug_windows) 488 fprintf (stderr, "\n\t%s(%6ld)", 489 i->data ? "realloc" : " malloc", (long) size_to_alloc); 490 i->data = (PTR) bfd_realloc (i->data, size_to_alloc); 491 if (debug_windows) 492 fprintf (stderr, "\t-> %p\n", i->data); 493 i->refcount = 1; 494 if (i->data == NULL) 495 { 496 if (size_to_alloc == 0) 497 return true; 498 bfd_set_error (bfd_error_no_memory); 499 return false; 500 } 501 if (bfd_seek (abfd, offset, SEEK_SET) != 0) 502 return false; 503 i->size = bfd_read (i->data, size, 1, abfd); 504 if (i->size != size) 505 return false; 506 i->mapped = 0; 507#ifdef HAVE_MPROTECT 508 if (!writable) 509 { 510 if (debug_windows) 511 fprintf (stderr, "\tmprotect (%p, %ld, PROT_READ)\n", i->data, 512 (long) i->size); 513 mprotect (i->data, i->size, PROT_READ); 514 } 515#endif 516 windowp->data = i->data; 517 windowp->size = i->size; 518 return true; 519} 520 521#endif /* USE_MMAP */ 522 523bfd_size_type 524bfd_write (ptr, size, nitems, abfd) 525 CONST PTR ptr; 526 bfd_size_type size; 527 bfd_size_type nitems; 528 bfd *abfd; 529{ 530 long nwrote; 531 532 if ((abfd->flags & BFD_IN_MEMORY) != 0) 533 { 534 struct bfd_in_memory *bim = (struct bfd_in_memory *) (abfd->iostream); 535 size *= nitems; 536 if (abfd->where + size > bim->size) 537 { 538 long newsize, oldsize = (bim->size + 127) & ~127; 539 bim->size = abfd->where + size; 540 /* Round up to cut down on memory fragmentation */ 541 newsize = (bim->size + 127) & ~127; 542 if (newsize > oldsize) 543 { 544 bim->buffer = bfd_realloc (bim->buffer, newsize); 545 if (bim->buffer == 0) 546 { 547 bim->size = 0; 548 return 0; 549 } 550 } 551 } 552 memcpy (bim->buffer + abfd->where, ptr, size); 553 abfd->where += size; 554 return size; 555 } 556 557 nwrote = fwrite (ptr, 1, (size_t) (size * nitems), 558 bfd_cache_lookup (abfd)); 559 if (nwrote > 0) 560 abfd->where += nwrote; 561 if ((bfd_size_type) nwrote != size * nitems) 562 { 563#ifdef ENOSPC 564 if (nwrote >= 0) 565 errno = ENOSPC; 566#endif 567 bfd_set_error (bfd_error_system_call); 568 } 569 return nwrote; 570} 571 572/* 573INTERNAL_FUNCTION 574 bfd_write_bigendian_4byte_int 575 576SYNOPSIS 577 void bfd_write_bigendian_4byte_int(bfd *abfd, int i); 578 579DESCRIPTION 580 Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big 581 endian order regardless of what else is going on. This is useful in 582 archives. 583 584*/ 585void 586bfd_write_bigendian_4byte_int (abfd, i) 587 bfd *abfd; 588 int i; 589{ 590 bfd_byte buffer[4]; 591 bfd_putb32(i, buffer); 592 if (bfd_write((PTR)buffer, 4, 1, abfd) != 4) 593 abort (); 594} 595 596long 597bfd_tell (abfd) 598 bfd *abfd; 599{ 600 file_ptr ptr; 601 602 if ((abfd->flags & BFD_IN_MEMORY) != 0) 603 return abfd->where; 604 605 ptr = ftell (bfd_cache_lookup(abfd)); 606 607 if (abfd->my_archive) 608 ptr -= abfd->origin; 609 abfd->where = ptr; 610 return ptr; 611} 612 613int 614bfd_flush (abfd) 615 bfd *abfd; 616{ 617 if ((abfd->flags & BFD_IN_MEMORY) != 0) 618 return 0; 619 return fflush (bfd_cache_lookup(abfd)); 620} 621 622/* Returns 0 for success, negative value for failure (in which case 623 bfd_get_error can retrieve the error code). */ 624int 625bfd_stat (abfd, statbuf) 626 bfd *abfd; 627 struct stat *statbuf; 628{ 629 FILE *f; 630 int result; 631 632 if ((abfd->flags & BFD_IN_MEMORY) != 0) 633 abort (); 634 635 f = bfd_cache_lookup (abfd); 636 if (f == NULL) 637 { 638 bfd_set_error (bfd_error_system_call); 639 return -1; 640 } 641 result = fstat (fileno (f), statbuf); 642 if (result < 0) 643 bfd_set_error (bfd_error_system_call); 644 return result; 645} 646 647/* Returns 0 for success, nonzero for failure (in which case bfd_get_error 648 can retrieve the error code). */ 649 650int 651bfd_seek (abfd, position, direction) 652 bfd *abfd; 653 file_ptr position; 654 int direction; 655{ 656 int result; 657 FILE *f; 658 file_ptr file_position; 659 /* For the time being, a BFD may not seek to it's end. The problem 660 is that we don't easily have a way to recognize the end of an 661 element in an archive. */ 662 663 BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR); 664 665 if (direction == SEEK_CUR && position == 0) 666 return 0; 667 668 if ((abfd->flags & BFD_IN_MEMORY) != 0) 669 { 670 struct bfd_in_memory *bim; 671 672 bim = (struct bfd_in_memory *) abfd->iostream; 673 674 if (direction == SEEK_SET) 675 abfd->where = position; 676 else 677 abfd->where += position; 678 679 if ((bfd_size_type) abfd->where > bim->size) 680 { 681 if ((abfd->direction == write_direction) || 682 (abfd->direction == both_direction)) 683 { 684 long newsize, oldsize = (bim->size + 127) & ~127; 685 bim->size = abfd->where; 686 /* Round up to cut down on memory fragmentation */ 687 newsize = (bim->size + 127) & ~127; 688 if (newsize > oldsize) 689 { 690 bim->buffer = bfd_realloc (bim->buffer, newsize); 691 if (bim->buffer == 0) 692 { 693 bim->size = 0; 694 bfd_set_error (bfd_error_no_memory); 695 return -1; 696 } 697 } 698 } 699 else 700 { 701 abfd->where = bim->size; 702 bfd_set_error (bfd_error_file_truncated); 703 return -1; 704 } 705 } 706 return 0; 707 } 708 709 if (abfd->format != bfd_archive && abfd->my_archive == 0) 710 { 711#if 0 712 /* Explanation for this code: I'm only about 95+% sure that the above 713 conditions are sufficient and that all i/o calls are properly 714 adjusting the `where' field. So this is sort of an `assert' 715 that the `where' field is correct. If we can go a while without 716 tripping the abort, we can probably safely disable this code, 717 so that the real optimizations happen. */ 718 file_ptr where_am_i_now; 719 where_am_i_now = ftell (bfd_cache_lookup (abfd)); 720 if (abfd->my_archive) 721 where_am_i_now -= abfd->origin; 722 if (where_am_i_now != abfd->where) 723 abort (); 724#endif 725 if (direction == SEEK_SET && position == abfd->where) 726 return 0; 727 } 728 else 729 { 730 /* We need something smarter to optimize access to archives. 731 Currently, anything inside an archive is read via the file 732 handle for the archive. Which means that a bfd_seek on one 733 component affects the `current position' in the archive, as 734 well as in any other component. 735 736 It might be sufficient to put a spike through the cache 737 abstraction, and look to the archive for the file position, 738 but I think we should try for something cleaner. 739 740 In the meantime, no optimization for archives. */ 741 } 742 743 f = bfd_cache_lookup (abfd); 744 file_position = position; 745 if (direction == SEEK_SET && abfd->my_archive != NULL) 746 file_position += abfd->origin; 747 748 result = fseek (f, file_position, direction); 749 750 if (result != 0) 751 { 752 int hold_errno = errno; 753 754 /* Force redetermination of `where' field. */ 755 bfd_tell (abfd); 756 757 /* An EINVAL error probably means that the file offset was 758 absurd. */ 759 if (hold_errno == EINVAL) 760 bfd_set_error (bfd_error_file_truncated); 761 else 762 { 763 bfd_set_error (bfd_error_system_call); 764 errno = hold_errno; 765 } 766 } 767 else 768 { 769 /* Adjust `where' field. */ 770 if (direction == SEEK_SET) 771 abfd->where = position; 772 else 773 abfd->where += position; 774 } 775 return result; 776} 777 778/** The do-it-yourself (byte) sex-change kit */ 779 780/* The middle letter e.g. get<b>short indicates Big or Little endian 781 target machine. It doesn't matter what the byte order of the host 782 machine is; these routines work for either. */ 783 784/* FIXME: Should these take a count argument? 785 Answer (gnu@cygnus.com): No, but perhaps they should be inline 786 functions in swap.h #ifdef __GNUC__. 787 Gprof them later and find out. */ 788 789/* 790FUNCTION 791 bfd_put_size 792FUNCTION 793 bfd_get_size 794 795DESCRIPTION 796 These macros as used for reading and writing raw data in 797 sections; each access (except for bytes) is vectored through 798 the target format of the BFD and mangled accordingly. The 799 mangling performs any necessary endian translations and 800 removes alignment restrictions. Note that types accepted and 801 returned by these macros are identical so they can be swapped 802 around in macros---for example, @file{libaout.h} defines <<GET_WORD>> 803 to either <<bfd_get_32>> or <<bfd_get_64>>. 804 805 In the put routines, @var{val} must be a <<bfd_vma>>. If we are on a 806 system without prototypes, the caller is responsible for making 807 sure that is true, with a cast if necessary. We don't cast 808 them in the macro definitions because that would prevent <<lint>> 809 or <<gcc -Wall>> from detecting sins such as passing a pointer. 810 To detect calling these with less than a <<bfd_vma>>, use 811 <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s. 812 813. 814.{* Byte swapping macros for user section data. *} 815. 816.#define bfd_put_8(abfd, val, ptr) \ 817. ((void) (*((unsigned char *) (ptr)) = (unsigned char) (val))) 818.#define bfd_put_signed_8 \ 819. bfd_put_8 820.#define bfd_get_8(abfd, ptr) \ 821. (*(unsigned char *) (ptr)) 822.#define bfd_get_signed_8(abfd, ptr) \ 823. ((*(unsigned char *) (ptr) ^ 0x80) - 0x80) 824. 825.#define bfd_put_16(abfd, val, ptr) \ 826. BFD_SEND(abfd, bfd_putx16, ((val),(ptr))) 827.#define bfd_put_signed_16 \ 828. bfd_put_16 829.#define bfd_get_16(abfd, ptr) \ 830. BFD_SEND(abfd, bfd_getx16, (ptr)) 831.#define bfd_get_signed_16(abfd, ptr) \ 832. BFD_SEND (abfd, bfd_getx_signed_16, (ptr)) 833. 834.#define bfd_put_32(abfd, val, ptr) \ 835. BFD_SEND(abfd, bfd_putx32, ((val),(ptr))) 836.#define bfd_put_signed_32 \ 837. bfd_put_32 838.#define bfd_get_32(abfd, ptr) \ 839. BFD_SEND(abfd, bfd_getx32, (ptr)) 840.#define bfd_get_signed_32(abfd, ptr) \ 841. BFD_SEND(abfd, bfd_getx_signed_32, (ptr)) 842. 843.#define bfd_put_64(abfd, val, ptr) \ 844. BFD_SEND(abfd, bfd_putx64, ((val), (ptr))) 845.#define bfd_put_signed_64 \ 846. bfd_put_64 847.#define bfd_get_64(abfd, ptr) \ 848. BFD_SEND(abfd, bfd_getx64, (ptr)) 849.#define bfd_get_signed_64(abfd, ptr) \ 850. BFD_SEND(abfd, bfd_getx_signed_64, (ptr)) 851. 852.#define bfd_get(bits, abfd, ptr) \ 853. ((bits) == 8 ? bfd_get_8 (abfd, ptr) \ 854. : (bits) == 16 ? bfd_get_16 (abfd, ptr) \ 855. : (bits) == 32 ? bfd_get_32 (abfd, ptr) \ 856. : (bits) == 64 ? bfd_get_64 (abfd, ptr) \ 857. : (abort (), (bfd_vma) - 1)) 858. 859.#define bfd_put(bits, abfd, val, ptr) \ 860. ((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \ 861. : (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \ 862. : (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \ 863. : (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \ 864. : (abort (), (void) 0)) 865. 866*/ 867 868/* 869FUNCTION 870 bfd_h_put_size 871 bfd_h_get_size 872 873DESCRIPTION 874 These macros have the same function as their <<bfd_get_x>> 875 bretheren, except that they are used for removing information 876 for the header records of object files. Believe it or not, 877 some object files keep their header records in big endian 878 order and their data in little endian order. 879. 880.{* Byte swapping macros for file header data. *} 881. 882.#define bfd_h_put_8(abfd, val, ptr) \ 883. bfd_put_8 (abfd, val, ptr) 884.#define bfd_h_put_signed_8(abfd, val, ptr) \ 885. bfd_put_8 (abfd, val, ptr) 886.#define bfd_h_get_8(abfd, ptr) \ 887. bfd_get_8 (abfd, ptr) 888.#define bfd_h_get_signed_8(abfd, ptr) \ 889. bfd_get_signed_8 (abfd, ptr) 890. 891.#define bfd_h_put_16(abfd, val, ptr) \ 892. BFD_SEND(abfd, bfd_h_putx16,(val,ptr)) 893.#define bfd_h_put_signed_16 \ 894. bfd_h_put_16 895.#define bfd_h_get_16(abfd, ptr) \ 896. BFD_SEND(abfd, bfd_h_getx16,(ptr)) 897.#define bfd_h_get_signed_16(abfd, ptr) \ 898. BFD_SEND(abfd, bfd_h_getx_signed_16, (ptr)) 899. 900.#define bfd_h_put_32(abfd, val, ptr) \ 901. BFD_SEND(abfd, bfd_h_putx32,(val,ptr)) 902.#define bfd_h_put_signed_32 \ 903. bfd_h_put_32 904.#define bfd_h_get_32(abfd, ptr) \ 905. BFD_SEND(abfd, bfd_h_getx32,(ptr)) 906.#define bfd_h_get_signed_32(abfd, ptr) \ 907. BFD_SEND(abfd, bfd_h_getx_signed_32, (ptr)) 908. 909.#define bfd_h_put_64(abfd, val, ptr) \ 910. BFD_SEND(abfd, bfd_h_putx64,(val, ptr)) 911.#define bfd_h_put_signed_64 \ 912. bfd_h_put_64 913.#define bfd_h_get_64(abfd, ptr) \ 914. BFD_SEND(abfd, bfd_h_getx64,(ptr)) 915.#define bfd_h_get_signed_64(abfd, ptr) \ 916. BFD_SEND(abfd, bfd_h_getx_signed_64, (ptr)) 917. 918*/ 919 920/* Sign extension to bfd_signed_vma. */ 921#define COERCE16(x) (((bfd_signed_vma) (x) ^ 0x8000) - 0x8000) 922#define COERCE32(x) \ 923 ((bfd_signed_vma) (long) (((unsigned long) (x) ^ 0x80000000) - 0x80000000)) 924#define EIGHT_GAZILLION (((BFD_HOST_64_BIT)0x80000000) << 32) 925#define COERCE64(x) \ 926 (((bfd_signed_vma) (x) ^ EIGHT_GAZILLION) - EIGHT_GAZILLION) 927 928bfd_vma 929bfd_getb16 (addr) 930 register const bfd_byte *addr; 931{ 932 return (addr[0] << 8) | addr[1]; 933} 934 935bfd_vma 936bfd_getl16 (addr) 937 register const bfd_byte *addr; 938{ 939 return (addr[1] << 8) | addr[0]; 940} 941 942bfd_signed_vma 943bfd_getb_signed_16 (addr) 944 register const bfd_byte *addr; 945{ 946 return COERCE16((addr[0] << 8) | addr[1]); 947} 948 949bfd_signed_vma 950bfd_getl_signed_16 (addr) 951 register const bfd_byte *addr; 952{ 953 return COERCE16((addr[1] << 8) | addr[0]); 954} 955 956void 957bfd_putb16 (data, addr) 958 bfd_vma data; 959 register bfd_byte *addr; 960{ 961 addr[0] = (bfd_byte) (data >> 8); 962 addr[1] = (bfd_byte )data; 963} 964 965void 966bfd_putl16 (data, addr) 967 bfd_vma data; 968 register bfd_byte *addr; 969{ 970 addr[0] = (bfd_byte )data; 971 addr[1] = (bfd_byte) (data >> 8); 972} 973 974bfd_vma 975bfd_getb32 (addr) 976 register const bfd_byte *addr; 977{ 978 unsigned long v; 979 980 v = (unsigned long) addr[0] << 24; 981 v |= (unsigned long) addr[1] << 16; 982 v |= (unsigned long) addr[2] << 8; 983 v |= (unsigned long) addr[3]; 984 return (bfd_vma) v; 985} 986 987bfd_vma 988bfd_getl32 (addr) 989 register const bfd_byte *addr; 990{ 991 unsigned long v; 992 993 v = (unsigned long) addr[0]; 994 v |= (unsigned long) addr[1] << 8; 995 v |= (unsigned long) addr[2] << 16; 996 v |= (unsigned long) addr[3] << 24; 997 return (bfd_vma) v; 998} 999 1000bfd_signed_vma 1001bfd_getb_signed_32 (addr) 1002 register const bfd_byte *addr; 1003{ 1004 unsigned long v; 1005 1006 v = (unsigned long) addr[0] << 24; 1007 v |= (unsigned long) addr[1] << 16; 1008 v |= (unsigned long) addr[2] << 8; 1009 v |= (unsigned long) addr[3]; 1010 return COERCE32 (v); 1011} 1012 1013bfd_signed_vma 1014bfd_getl_signed_32 (addr) 1015 register const bfd_byte *addr; 1016{ 1017 unsigned long v; 1018 1019 v = (unsigned long) addr[0]; 1020 v |= (unsigned long) addr[1] << 8; 1021 v |= (unsigned long) addr[2] << 16; 1022 v |= (unsigned long) addr[3] << 24; 1023 return COERCE32 (v); 1024} 1025 1026bfd_vma 1027bfd_getb64 (addr) 1028 register const bfd_byte *addr ATTRIBUTE_UNUSED; 1029{ 1030#ifdef BFD64 1031 bfd_vma low, high; 1032 1033 high= ((((((((addr[0]) << 8) | 1034 addr[1]) << 8) | 1035 addr[2]) << 8) | 1036 addr[3]) ); 1037 1038 low = (((((((((bfd_vma)addr[4]) << 8) | 1039 addr[5]) << 8) | 1040 addr[6]) << 8) | 1041 addr[7])); 1042 1043 return high << 32 | low; 1044#else 1045 BFD_FAIL(); 1046 return 0; 1047#endif 1048} 1049 1050bfd_vma 1051bfd_getl64 (addr) 1052 register const bfd_byte *addr ATTRIBUTE_UNUSED; 1053{ 1054#ifdef BFD64 1055 bfd_vma low, high; 1056 high= (((((((addr[7] << 8) | 1057 addr[6]) << 8) | 1058 addr[5]) << 8) | 1059 addr[4])); 1060 1061 low = ((((((((bfd_vma)addr[3] << 8) | 1062 addr[2]) << 8) | 1063 addr[1]) << 8) | 1064 addr[0]) ); 1065 1066 return high << 32 | low; 1067#else 1068 BFD_FAIL(); 1069 return 0; 1070#endif 1071 1072} 1073 1074bfd_signed_vma 1075bfd_getb_signed_64 (addr) 1076 register const bfd_byte *addr ATTRIBUTE_UNUSED; 1077{ 1078#ifdef BFD64 1079 bfd_vma low, high; 1080 1081 high= ((((((((addr[0]) << 8) | 1082 addr[1]) << 8) | 1083 addr[2]) << 8) | 1084 addr[3]) ); 1085 1086 low = (((((((((bfd_vma)addr[4]) << 8) | 1087 addr[5]) << 8) | 1088 addr[6]) << 8) | 1089 addr[7])); 1090 1091 return COERCE64(high << 32 | low); 1092#else 1093 BFD_FAIL(); 1094 return 0; 1095#endif 1096} 1097 1098bfd_signed_vma 1099bfd_getl_signed_64 (addr) 1100 register const bfd_byte *addr ATTRIBUTE_UNUSED; 1101{ 1102#ifdef BFD64 1103 bfd_vma low, high; 1104 high= (((((((addr[7] << 8) | 1105 addr[6]) << 8) | 1106 addr[5]) << 8) | 1107 addr[4])); 1108 1109 low = ((((((((bfd_vma)addr[3] << 8) | 1110 addr[2]) << 8) | 1111 addr[1]) << 8) | 1112 addr[0]) ); 1113 1114 return COERCE64(high << 32 | low); 1115#else 1116 BFD_FAIL(); 1117 return 0; 1118#endif 1119} 1120 1121void 1122bfd_putb32 (data, addr) 1123 bfd_vma data; 1124 register bfd_byte *addr; 1125{ 1126 addr[0] = (bfd_byte) (data >> 24); 1127 addr[1] = (bfd_byte) (data >> 16); 1128 addr[2] = (bfd_byte) (data >> 8); 1129 addr[3] = (bfd_byte)data; 1130} 1131 1132void 1133bfd_putl32 (data, addr) 1134 bfd_vma data; 1135 register bfd_byte *addr; 1136{ 1137 addr[0] = (bfd_byte)data; 1138 addr[1] = (bfd_byte) (data >> 8); 1139 addr[2] = (bfd_byte) (data >> 16); 1140 addr[3] = (bfd_byte) (data >> 24); 1141} 1142 1143void 1144bfd_putb64 (data, addr) 1145 bfd_vma data ATTRIBUTE_UNUSED; 1146 register bfd_byte *addr ATTRIBUTE_UNUSED; 1147{ 1148#ifdef BFD64 1149 addr[0] = (bfd_byte) (data >> (7*8)); 1150 addr[1] = (bfd_byte) (data >> (6*8)); 1151 addr[2] = (bfd_byte) (data >> (5*8)); 1152 addr[3] = (bfd_byte) (data >> (4*8)); 1153 addr[4] = (bfd_byte) (data >> (3*8)); 1154 addr[5] = (bfd_byte) (data >> (2*8)); 1155 addr[6] = (bfd_byte) (data >> (1*8)); 1156 addr[7] = (bfd_byte) (data >> (0*8)); 1157#else 1158 BFD_FAIL(); 1159#endif 1160} 1161 1162void 1163bfd_putl64 (data, addr) 1164 bfd_vma data ATTRIBUTE_UNUSED; 1165 register bfd_byte *addr ATTRIBUTE_UNUSED; 1166{ 1167#ifdef BFD64 1168 addr[7] = (bfd_byte) (data >> (7*8)); 1169 addr[6] = (bfd_byte) (data >> (6*8)); 1170 addr[5] = (bfd_byte) (data >> (5*8)); 1171 addr[4] = (bfd_byte) (data >> (4*8)); 1172 addr[3] = (bfd_byte) (data >> (3*8)); 1173 addr[2] = (bfd_byte) (data >> (2*8)); 1174 addr[1] = (bfd_byte) (data >> (1*8)); 1175 addr[0] = (bfd_byte) (data >> (0*8)); 1176#else 1177 BFD_FAIL(); 1178#endif 1179} 1180 1181void 1182bfd_put_bits (data, addr, bits, big_p) 1183 bfd_vma data; 1184 bfd_byte *addr; 1185 int bits; 1186 boolean big_p; 1187{ 1188 int i; 1189 int bytes; 1190 1191 if (bits % 8 != 0) 1192 abort (); 1193 1194 bytes = bits / 8; 1195 for (i = 0; i < bytes; i++) 1196 { 1197 int index = big_p ? bytes - i - 1 : i; 1198 1199 addr[index] = (bfd_byte) data; 1200 data >>= 8; 1201 } 1202} 1203 1204bfd_vma 1205bfd_get_bits (addr, bits, big_p) 1206 bfd_byte *addr; 1207 int bits; 1208 boolean big_p; 1209{ 1210 bfd_vma data; 1211 int i; 1212 int bytes; 1213 1214 if (bits % 8 != 0) 1215 abort (); 1216 1217 data = 0; 1218 bytes = bits / 8; 1219 for (i = 0; i < bytes; i++) 1220 { 1221 int index = big_p ? i : bytes - i - 1; 1222 1223 data = (data << 8) | addr[index]; 1224 } 1225 1226 return data; 1227} 1228 1229/* Default implementation */ 1230 1231boolean 1232_bfd_generic_get_section_contents (abfd, section, location, offset, count) 1233 bfd *abfd; 1234 sec_ptr section; 1235 PTR location; 1236 file_ptr offset; 1237 bfd_size_type count; 1238{ 1239 if (count == 0) 1240 return true; 1241 1242 if ((bfd_size_type) (offset + count) > section->_raw_size) 1243 { 1244 bfd_set_error (bfd_error_invalid_operation); 1245 return false; 1246 } 1247 1248 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0 1249 || bfd_read (location, (bfd_size_type) 1, count, abfd) != count) 1250 return false; 1251 1252 return true; 1253} 1254 1255boolean 1256_bfd_generic_get_section_contents_in_window (abfd, section, w, offset, count) 1257 bfd *abfd ATTRIBUTE_UNUSED; 1258 sec_ptr section ATTRIBUTE_UNUSED; 1259 bfd_window *w ATTRIBUTE_UNUSED; 1260 file_ptr offset ATTRIBUTE_UNUSED; 1261 bfd_size_type count ATTRIBUTE_UNUSED; 1262{ 1263#ifdef USE_MMAP 1264 if (count == 0) 1265 return true; 1266 if (abfd->xvec->_bfd_get_section_contents != _bfd_generic_get_section_contents) 1267 { 1268 /* We don't know what changes the bfd's get_section_contents 1269 method may have to make. So punt trying to map the file 1270 window, and let get_section_contents do its thing. */ 1271 /* @@ FIXME : If the internal window has a refcount of 1 and was 1272 allocated with malloc instead of mmap, just reuse it. */ 1273 bfd_free_window (w); 1274 w->i = (bfd_window_internal *) bfd_zmalloc (sizeof (bfd_window_internal)); 1275 if (w->i == NULL) 1276 return false; 1277 w->i->data = (PTR) bfd_malloc ((size_t) count); 1278 if (w->i->data == NULL) 1279 { 1280 free (w->i); 1281 w->i = NULL; 1282 return false; 1283 } 1284 w->i->mapped = 0; 1285 w->i->refcount = 1; 1286 w->size = w->i->size = count; 1287 w->data = w->i->data; 1288 return bfd_get_section_contents (abfd, section, w->data, offset, count); 1289 } 1290 if ((bfd_size_type) (offset+count) > section->_raw_size 1291 || (bfd_get_file_window (abfd, section->filepos + offset, count, w, true) 1292 == false)) 1293 return false; 1294 return true; 1295#else 1296 abort (); 1297#endif 1298} 1299 1300/* This generic function can only be used in implementations where creating 1301 NEW sections is disallowed. It is useful in patching existing sections 1302 in read-write files, though. See other set_section_contents functions 1303 to see why it doesn't work for new sections. */ 1304boolean 1305_bfd_generic_set_section_contents (abfd, section, location, offset, count) 1306 bfd *abfd; 1307 sec_ptr section; 1308 PTR location; 1309 file_ptr offset; 1310 bfd_size_type count; 1311{ 1312 if (count == 0) 1313 return true; 1314 1315 if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) == -1 1316 || bfd_write (location, (bfd_size_type) 1, count, abfd) != count) 1317 return false; 1318 1319 return true; 1320} 1321 1322/* 1323INTERNAL_FUNCTION 1324 bfd_log2 1325 1326SYNOPSIS 1327 unsigned int bfd_log2(bfd_vma x); 1328 1329DESCRIPTION 1330 Return the log base 2 of the value supplied, rounded up. E.g., an 1331 @var{x} of 1025 returns 11. 1332*/ 1333 1334unsigned int 1335bfd_log2 (x) 1336 bfd_vma x; 1337{ 1338 unsigned int result = 0; 1339 1340 while ((x = (x >> 1)) != 0) 1341 ++result; 1342 return result; 1343} 1344 1345boolean 1346bfd_generic_is_local_label_name (abfd, name) 1347 bfd *abfd; 1348 const char *name; 1349{ 1350 char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.'; 1351 1352 return (name[0] == locals_prefix); 1353} 1354 1355/* Can be used from / for bfd_merge_private_bfd_data to check that 1356 endianness matches between input and output file. Returns 1357 true for a match, otherwise returns false and emits an error. */ 1358boolean 1359_bfd_generic_verify_endian_match (ibfd, obfd) 1360 bfd *ibfd; 1361 bfd *obfd; 1362{ 1363 if (ibfd->xvec->byteorder != obfd->xvec->byteorder 1364 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN 1365 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN) 1366 { 1367 const char *msg; 1368 1369 if (bfd_big_endian (ibfd)) 1370 msg = _("%s: compiled for a big endian system and target is little endian"); 1371 else 1372 msg = _("%s: compiled for a little endian system and target is big endian"); 1373 1374 (*_bfd_error_handler) (msg, bfd_get_filename (ibfd)); 1375 1376 bfd_set_error (bfd_error_wrong_format); 1377 return false; 1378 } 1379 1380 return true; 1381} 1382