1/* Assorted BFD support routines, only used internally. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002, 2003, 2004 4 Free Software Foundation, Inc. 5 Written by Cygnus Support. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 22 23#include "bfd.h" 24#include "sysdep.h" 25#include "libbfd.h" 26 27#ifndef HAVE_GETPAGESIZE 28#define getpagesize() 2048 29#endif 30 31/* 32SECTION 33 Internal functions 34 35DESCRIPTION 36 These routines are used within BFD. 37 They are not intended for export, but are documented here for 38 completeness. 39*/ 40 41/* A routine which is used in target vectors for unsupported 42 operations. */ 43 44bfd_boolean 45bfd_false (bfd *ignore ATTRIBUTE_UNUSED) 46{ 47 bfd_set_error (bfd_error_invalid_operation); 48 return FALSE; 49} 50 51/* A routine which is used in target vectors for supported operations 52 which do not actually do anything. */ 53 54bfd_boolean 55bfd_true (bfd *ignore ATTRIBUTE_UNUSED) 56{ 57 return TRUE; 58} 59 60/* A routine which is used in target vectors for unsupported 61 operations which return a pointer value. */ 62 63void * 64bfd_nullvoidptr (bfd *ignore ATTRIBUTE_UNUSED) 65{ 66 bfd_set_error (bfd_error_invalid_operation); 67 return NULL; 68} 69 70int 71bfd_0 (bfd *ignore ATTRIBUTE_UNUSED) 72{ 73 return 0; 74} 75 76unsigned int 77bfd_0u (bfd *ignore ATTRIBUTE_UNUSED) 78{ 79 return 0; 80} 81 82long 83bfd_0l (bfd *ignore ATTRIBUTE_UNUSED) 84{ 85 return 0; 86} 87 88/* A routine which is used in target vectors for unsupported 89 operations which return -1 on error. */ 90 91long 92_bfd_n1 (bfd *ignore_abfd ATTRIBUTE_UNUSED) 93{ 94 bfd_set_error (bfd_error_invalid_operation); 95 return -1; 96} 97 98void 99bfd_void (bfd *ignore ATTRIBUTE_UNUSED) 100{ 101} 102 103bfd_boolean 104_bfd_nocore_core_file_matches_executable_p 105 (bfd *ignore_core_bfd ATTRIBUTE_UNUSED, 106 bfd *ignore_exec_bfd ATTRIBUTE_UNUSED) 107{ 108 bfd_set_error (bfd_error_invalid_operation); 109 return FALSE; 110} 111 112/* Routine to handle core_file_failing_command entry point for targets 113 without core file support. */ 114 115char * 116_bfd_nocore_core_file_failing_command (bfd *ignore_abfd ATTRIBUTE_UNUSED) 117{ 118 bfd_set_error (bfd_error_invalid_operation); 119 return NULL; 120} 121 122/* Routine to handle core_file_failing_signal entry point for targets 123 without core file support. */ 124 125int 126_bfd_nocore_core_file_failing_signal (bfd *ignore_abfd ATTRIBUTE_UNUSED) 127{ 128 bfd_set_error (bfd_error_invalid_operation); 129 return 0; 130} 131 132const bfd_target * 133_bfd_dummy_target (bfd *ignore_abfd ATTRIBUTE_UNUSED) 134{ 135 bfd_set_error (bfd_error_wrong_format); 136 return 0; 137} 138 139/* Allocate memory using malloc. */ 140 141void * 142bfd_malloc (bfd_size_type size) 143{ 144 void *ptr; 145 146 if (size != (size_t) size) 147 { 148 bfd_set_error (bfd_error_no_memory); 149 return NULL; 150 } 151 152 ptr = malloc ((size_t) size); 153 if (ptr == NULL && (size_t) size != 0) 154 bfd_set_error (bfd_error_no_memory); 155 156 return ptr; 157} 158 159/* Reallocate memory using realloc. */ 160 161void * 162bfd_realloc (void *ptr, bfd_size_type size) 163{ 164 void *ret; 165 166 if (size != (size_t) size) 167 { 168 bfd_set_error (bfd_error_no_memory); 169 return NULL; 170 } 171 172 if (ptr == NULL) 173 ret = malloc ((size_t) size); 174 else 175 ret = realloc (ptr, (size_t) size); 176 177 if (ret == NULL && (size_t) size != 0) 178 bfd_set_error (bfd_error_no_memory); 179 180 return ret; 181} 182 183/* Allocate memory using malloc and clear it. */ 184 185void * 186bfd_zmalloc (bfd_size_type size) 187{ 188 void *ptr; 189 190 if (size != (size_t) size) 191 { 192 bfd_set_error (bfd_error_no_memory); 193 return NULL; 194 } 195 196 ptr = malloc ((size_t) size); 197 198 if ((size_t) size != 0) 199 { 200 if (ptr == NULL) 201 bfd_set_error (bfd_error_no_memory); 202 else 203 memset (ptr, 0, (size_t) size); 204 } 205 206 return ptr; 207} 208/* 209INTERNAL_FUNCTION 210 bfd_write_bigendian_4byte_int 211 212SYNOPSIS 213 bfd_boolean bfd_write_bigendian_4byte_int (bfd *, unsigned int); 214 215DESCRIPTION 216 Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big 217 endian order regardless of what else is going on. This is useful in 218 archives. 219 220*/ 221bfd_boolean 222bfd_write_bigendian_4byte_int (bfd *abfd, unsigned int i) 223{ 224 bfd_byte buffer[4]; 225 bfd_putb32 ((bfd_vma) i, buffer); 226 return bfd_bwrite (buffer, (bfd_size_type) 4, abfd) == 4; 227} 228 229 230/** The do-it-yourself (byte) sex-change kit */ 231 232/* The middle letter e.g. get<b>short indicates Big or Little endian 233 target machine. It doesn't matter what the byte order of the host 234 machine is; these routines work for either. */ 235 236/* FIXME: Should these take a count argument? 237 Answer (gnu@cygnus.com): No, but perhaps they should be inline 238 functions in swap.h #ifdef __GNUC__. 239 Gprof them later and find out. */ 240 241/* 242FUNCTION 243 bfd_put_size 244FUNCTION 245 bfd_get_size 246 247DESCRIPTION 248 These macros as used for reading and writing raw data in 249 sections; each access (except for bytes) is vectored through 250 the target format of the BFD and mangled accordingly. The 251 mangling performs any necessary endian translations and 252 removes alignment restrictions. Note that types accepted and 253 returned by these macros are identical so they can be swapped 254 around in macros---for example, @file{libaout.h} defines <<GET_WORD>> 255 to either <<bfd_get_32>> or <<bfd_get_64>>. 256 257 In the put routines, @var{val} must be a <<bfd_vma>>. If we are on a 258 system without prototypes, the caller is responsible for making 259 sure that is true, with a cast if necessary. We don't cast 260 them in the macro definitions because that would prevent <<lint>> 261 or <<gcc -Wall>> from detecting sins such as passing a pointer. 262 To detect calling these with less than a <<bfd_vma>>, use 263 <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s. 264 265. 266.{* Byte swapping macros for user section data. *} 267. 268.#define bfd_put_8(abfd, val, ptr) \ 269. ((void) (*((unsigned char *) (ptr)) = (val) & 0xff)) 270.#define bfd_put_signed_8 \ 271. bfd_put_8 272.#define bfd_get_8(abfd, ptr) \ 273. (*(unsigned char *) (ptr) & 0xff) 274.#define bfd_get_signed_8(abfd, ptr) \ 275. (((*(unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80) 276. 277.#define bfd_put_16(abfd, val, ptr) \ 278. BFD_SEND (abfd, bfd_putx16, ((val),(ptr))) 279.#define bfd_put_signed_16 \ 280. bfd_put_16 281.#define bfd_get_16(abfd, ptr) \ 282. BFD_SEND (abfd, bfd_getx16, (ptr)) 283.#define bfd_get_signed_16(abfd, ptr) \ 284. BFD_SEND (abfd, bfd_getx_signed_16, (ptr)) 285. 286.#define bfd_put_32(abfd, val, ptr) \ 287. BFD_SEND (abfd, bfd_putx32, ((val),(ptr))) 288.#define bfd_put_signed_32 \ 289. bfd_put_32 290.#define bfd_get_32(abfd, ptr) \ 291. BFD_SEND (abfd, bfd_getx32, (ptr)) 292.#define bfd_get_signed_32(abfd, ptr) \ 293. BFD_SEND (abfd, bfd_getx_signed_32, (ptr)) 294. 295.#define bfd_put_64(abfd, val, ptr) \ 296. BFD_SEND (abfd, bfd_putx64, ((val), (ptr))) 297.#define bfd_put_signed_64 \ 298. bfd_put_64 299.#define bfd_get_64(abfd, ptr) \ 300. BFD_SEND (abfd, bfd_getx64, (ptr)) 301.#define bfd_get_signed_64(abfd, ptr) \ 302. BFD_SEND (abfd, bfd_getx_signed_64, (ptr)) 303. 304.#define bfd_get(bits, abfd, ptr) \ 305. ((bits) == 8 ? (bfd_vma) bfd_get_8 (abfd, ptr) \ 306. : (bits) == 16 ? bfd_get_16 (abfd, ptr) \ 307. : (bits) == 32 ? bfd_get_32 (abfd, ptr) \ 308. : (bits) == 64 ? bfd_get_64 (abfd, ptr) \ 309. : (abort (), (bfd_vma) - 1)) 310. 311.#define bfd_put(bits, abfd, val, ptr) \ 312. ((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \ 313. : (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \ 314. : (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \ 315. : (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \ 316. : (abort (), (void) 0)) 317. 318*/ 319 320/* 321FUNCTION 322 bfd_h_put_size 323 bfd_h_get_size 324 325DESCRIPTION 326 These macros have the same function as their <<bfd_get_x>> 327 brethren, except that they are used for removing information 328 for the header records of object files. Believe it or not, 329 some object files keep their header records in big endian 330 order and their data in little endian order. 331. 332.{* Byte swapping macros for file header data. *} 333. 334.#define bfd_h_put_8(abfd, val, ptr) \ 335. bfd_put_8 (abfd, val, ptr) 336.#define bfd_h_put_signed_8(abfd, val, ptr) \ 337. bfd_put_8 (abfd, val, ptr) 338.#define bfd_h_get_8(abfd, ptr) \ 339. bfd_get_8 (abfd, ptr) 340.#define bfd_h_get_signed_8(abfd, ptr) \ 341. bfd_get_signed_8 (abfd, ptr) 342. 343.#define bfd_h_put_16(abfd, val, ptr) \ 344. BFD_SEND (abfd, bfd_h_putx16, (val, ptr)) 345.#define bfd_h_put_signed_16 \ 346. bfd_h_put_16 347.#define bfd_h_get_16(abfd, ptr) \ 348. BFD_SEND (abfd, bfd_h_getx16, (ptr)) 349.#define bfd_h_get_signed_16(abfd, ptr) \ 350. BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr)) 351. 352.#define bfd_h_put_32(abfd, val, ptr) \ 353. BFD_SEND (abfd, bfd_h_putx32, (val, ptr)) 354.#define bfd_h_put_signed_32 \ 355. bfd_h_put_32 356.#define bfd_h_get_32(abfd, ptr) \ 357. BFD_SEND (abfd, bfd_h_getx32, (ptr)) 358.#define bfd_h_get_signed_32(abfd, ptr) \ 359. BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr)) 360. 361.#define bfd_h_put_64(abfd, val, ptr) \ 362. BFD_SEND (abfd, bfd_h_putx64, (val, ptr)) 363.#define bfd_h_put_signed_64 \ 364. bfd_h_put_64 365.#define bfd_h_get_64(abfd, ptr) \ 366. BFD_SEND (abfd, bfd_h_getx64, (ptr)) 367.#define bfd_h_get_signed_64(abfd, ptr) \ 368. BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr)) 369. 370.{* Aliases for the above, which should eventually go away. *} 371. 372.#define H_PUT_64 bfd_h_put_64 373.#define H_PUT_32 bfd_h_put_32 374.#define H_PUT_16 bfd_h_put_16 375.#define H_PUT_8 bfd_h_put_8 376.#define H_PUT_S64 bfd_h_put_signed_64 377.#define H_PUT_S32 bfd_h_put_signed_32 378.#define H_PUT_S16 bfd_h_put_signed_16 379.#define H_PUT_S8 bfd_h_put_signed_8 380.#define H_GET_64 bfd_h_get_64 381.#define H_GET_32 bfd_h_get_32 382.#define H_GET_16 bfd_h_get_16 383.#define H_GET_8 bfd_h_get_8 384.#define H_GET_S64 bfd_h_get_signed_64 385.#define H_GET_S32 bfd_h_get_signed_32 386.#define H_GET_S16 bfd_h_get_signed_16 387.#define H_GET_S8 bfd_h_get_signed_8 388. 389.*/ 390 391/* Sign extension to bfd_signed_vma. */ 392#define COERCE16(x) (((bfd_signed_vma) (x) ^ 0x8000) - 0x8000) 393#define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000) 394#define EIGHT_GAZILLION ((bfd_int64_t) 1 << 63) 395#define COERCE64(x) \ 396 (((bfd_int64_t) (x) ^ EIGHT_GAZILLION) - EIGHT_GAZILLION) 397 398bfd_vma 399bfd_getb16 (const void *p) 400{ 401 const bfd_byte *addr = p; 402 return (addr[0] << 8) | addr[1]; 403} 404 405bfd_vma 406bfd_getl16 (const void *p) 407{ 408 const bfd_byte *addr = p; 409 return (addr[1] << 8) | addr[0]; 410} 411 412bfd_signed_vma 413bfd_getb_signed_16 (const void *p) 414{ 415 const bfd_byte *addr = p; 416 return COERCE16 ((addr[0] << 8) | addr[1]); 417} 418 419bfd_signed_vma 420bfd_getl_signed_16 (const void *p) 421{ 422 const bfd_byte *addr = p; 423 return COERCE16 ((addr[1] << 8) | addr[0]); 424} 425 426void 427bfd_putb16 (bfd_vma data, void *p) 428{ 429 bfd_byte *addr = p; 430 addr[0] = (data >> 8) & 0xff; 431 addr[1] = data & 0xff; 432} 433 434void 435bfd_putl16 (bfd_vma data, void *p) 436{ 437 bfd_byte *addr = p; 438 addr[0] = data & 0xff; 439 addr[1] = (data >> 8) & 0xff; 440} 441 442bfd_vma 443bfd_getb32 (const void *p) 444{ 445 const bfd_byte *addr = p; 446 unsigned long v; 447 448 v = (unsigned long) addr[0] << 24; 449 v |= (unsigned long) addr[1] << 16; 450 v |= (unsigned long) addr[2] << 8; 451 v |= (unsigned long) addr[3]; 452 return v; 453} 454 455bfd_vma 456bfd_getl32 (const void *p) 457{ 458 const bfd_byte *addr = p; 459 unsigned long v; 460 461 v = (unsigned long) addr[0]; 462 v |= (unsigned long) addr[1] << 8; 463 v |= (unsigned long) addr[2] << 16; 464 v |= (unsigned long) addr[3] << 24; 465 return v; 466} 467 468bfd_signed_vma 469bfd_getb_signed_32 (const void *p) 470{ 471 const bfd_byte *addr = p; 472 unsigned long v; 473 474 v = (unsigned long) addr[0] << 24; 475 v |= (unsigned long) addr[1] << 16; 476 v |= (unsigned long) addr[2] << 8; 477 v |= (unsigned long) addr[3]; 478 return COERCE32 (v); 479} 480 481bfd_signed_vma 482bfd_getl_signed_32 (const void *p) 483{ 484 const bfd_byte *addr = p; 485 unsigned long v; 486 487 v = (unsigned long) addr[0]; 488 v |= (unsigned long) addr[1] << 8; 489 v |= (unsigned long) addr[2] << 16; 490 v |= (unsigned long) addr[3] << 24; 491 return COERCE32 (v); 492} 493 494bfd_uint64_t 495bfd_getb64 (const void *p ATTRIBUTE_UNUSED) 496{ 497#ifdef BFD_HOST_64_BIT 498 const bfd_byte *addr = p; 499 bfd_uint64_t v; 500 501 v = addr[0]; v <<= 8; 502 v |= addr[1]; v <<= 8; 503 v |= addr[2]; v <<= 8; 504 v |= addr[3]; v <<= 8; 505 v |= addr[4]; v <<= 8; 506 v |= addr[5]; v <<= 8; 507 v |= addr[6]; v <<= 8; 508 v |= addr[7]; 509 510 return v; 511#else 512 BFD_FAIL(); 513 return 0; 514#endif 515} 516 517bfd_uint64_t 518bfd_getl64 (const void *p ATTRIBUTE_UNUSED) 519{ 520#ifdef BFD_HOST_64_BIT 521 const bfd_byte *addr = p; 522 bfd_uint64_t v; 523 524 v = addr[7]; v <<= 8; 525 v |= addr[6]; v <<= 8; 526 v |= addr[5]; v <<= 8; 527 v |= addr[4]; v <<= 8; 528 v |= addr[3]; v <<= 8; 529 v |= addr[2]; v <<= 8; 530 v |= addr[1]; v <<= 8; 531 v |= addr[0]; 532 533 return v; 534#else 535 BFD_FAIL(); 536 return 0; 537#endif 538 539} 540 541bfd_int64_t 542bfd_getb_signed_64 (const void *p ATTRIBUTE_UNUSED) 543{ 544#ifdef BFD_HOST_64_BIT 545 const bfd_byte *addr = p; 546 bfd_uint64_t v; 547 548 v = addr[0]; v <<= 8; 549 v |= addr[1]; v <<= 8; 550 v |= addr[2]; v <<= 8; 551 v |= addr[3]; v <<= 8; 552 v |= addr[4]; v <<= 8; 553 v |= addr[5]; v <<= 8; 554 v |= addr[6]; v <<= 8; 555 v |= addr[7]; 556 557 return COERCE64 (v); 558#else 559 BFD_FAIL(); 560 return 0; 561#endif 562} 563 564bfd_int64_t 565bfd_getl_signed_64 (const void *p ATTRIBUTE_UNUSED) 566{ 567#ifdef BFD_HOST_64_BIT 568 const bfd_byte *addr = p; 569 bfd_uint64_t v; 570 571 v = addr[7]; v <<= 8; 572 v |= addr[6]; v <<= 8; 573 v |= addr[5]; v <<= 8; 574 v |= addr[4]; v <<= 8; 575 v |= addr[3]; v <<= 8; 576 v |= addr[2]; v <<= 8; 577 v |= addr[1]; v <<= 8; 578 v |= addr[0]; 579 580 return COERCE64 (v); 581#else 582 BFD_FAIL(); 583 return 0; 584#endif 585} 586 587void 588bfd_putb32 (bfd_vma data, void *p) 589{ 590 bfd_byte *addr = p; 591 addr[0] = (data >> 24) & 0xff; 592 addr[1] = (data >> 16) & 0xff; 593 addr[2] = (data >> 8) & 0xff; 594 addr[3] = data & 0xff; 595} 596 597void 598bfd_putl32 (bfd_vma data, void *p) 599{ 600 bfd_byte *addr = p; 601 addr[0] = data & 0xff; 602 addr[1] = (data >> 8) & 0xff; 603 addr[2] = (data >> 16) & 0xff; 604 addr[3] = (data >> 24) & 0xff; 605} 606 607void 608bfd_putb64 (bfd_uint64_t data ATTRIBUTE_UNUSED, void *p ATTRIBUTE_UNUSED) 609{ 610#ifdef BFD_HOST_64_BIT 611 bfd_byte *addr = p; 612 addr[0] = (data >> (7*8)) & 0xff; 613 addr[1] = (data >> (6*8)) & 0xff; 614 addr[2] = (data >> (5*8)) & 0xff; 615 addr[3] = (data >> (4*8)) & 0xff; 616 addr[4] = (data >> (3*8)) & 0xff; 617 addr[5] = (data >> (2*8)) & 0xff; 618 addr[6] = (data >> (1*8)) & 0xff; 619 addr[7] = (data >> (0*8)) & 0xff; 620#else 621 BFD_FAIL(); 622#endif 623} 624 625void 626bfd_putl64 (bfd_uint64_t data ATTRIBUTE_UNUSED, void *p ATTRIBUTE_UNUSED) 627{ 628#ifdef BFD_HOST_64_BIT 629 bfd_byte *addr = p; 630 addr[7] = (data >> (7*8)) & 0xff; 631 addr[6] = (data >> (6*8)) & 0xff; 632 addr[5] = (data >> (5*8)) & 0xff; 633 addr[4] = (data >> (4*8)) & 0xff; 634 addr[3] = (data >> (3*8)) & 0xff; 635 addr[2] = (data >> (2*8)) & 0xff; 636 addr[1] = (data >> (1*8)) & 0xff; 637 addr[0] = (data >> (0*8)) & 0xff; 638#else 639 BFD_FAIL(); 640#endif 641} 642 643void 644bfd_put_bits (bfd_uint64_t data, void *p, int bits, bfd_boolean big_p) 645{ 646 bfd_byte *addr = p; 647 int i; 648 int bytes; 649 650 if (bits % 8 != 0) 651 abort (); 652 653 bytes = bits / 8; 654 for (i = 0; i < bytes; i++) 655 { 656 int index = big_p ? bytes - i - 1 : i; 657 658 addr[index] = data & 0xff; 659 data >>= 8; 660 } 661} 662 663bfd_uint64_t 664bfd_get_bits (const void *p, int bits, bfd_boolean big_p) 665{ 666 const bfd_byte *addr = p; 667 bfd_uint64_t data; 668 int i; 669 int bytes; 670 671 if (bits % 8 != 0) 672 abort (); 673 674 data = 0; 675 bytes = bits / 8; 676 for (i = 0; i < bytes; i++) 677 { 678 int index = big_p ? i : bytes - i - 1; 679 680 data = (data << 8) | addr[index]; 681 } 682 683 return data; 684} 685 686/* Default implementation */ 687 688bfd_boolean 689_bfd_generic_get_section_contents (bfd *abfd, 690 sec_ptr section, 691 void *location, 692 file_ptr offset, 693 bfd_size_type count) 694{ 695 bfd_size_type sz; 696 if (count == 0) 697 return TRUE; 698 699 sz = section->rawsize ? section->rawsize : section->size; 700 if (offset + count > sz) 701 { 702 bfd_set_error (bfd_error_invalid_operation); 703 return FALSE; 704 } 705 706 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0 707 || bfd_bread (location, count, abfd) != count) 708 return FALSE; 709 710 return TRUE; 711} 712 713bfd_boolean 714_bfd_generic_get_section_contents_in_window 715 (bfd *abfd ATTRIBUTE_UNUSED, 716 sec_ptr section ATTRIBUTE_UNUSED, 717 bfd_window *w ATTRIBUTE_UNUSED, 718 file_ptr offset ATTRIBUTE_UNUSED, 719 bfd_size_type count ATTRIBUTE_UNUSED) 720{ 721#ifdef USE_MMAP 722 bfd_size_type sz; 723 724 if (count == 0) 725 return TRUE; 726 if (abfd->xvec->_bfd_get_section_contents 727 != _bfd_generic_get_section_contents) 728 { 729 /* We don't know what changes the bfd's get_section_contents 730 method may have to make. So punt trying to map the file 731 window, and let get_section_contents do its thing. */ 732 /* @@ FIXME : If the internal window has a refcount of 1 and was 733 allocated with malloc instead of mmap, just reuse it. */ 734 bfd_free_window (w); 735 w->i = bfd_zmalloc (sizeof (bfd_window_internal)); 736 if (w->i == NULL) 737 return FALSE; 738 w->i->data = bfd_malloc (count); 739 if (w->i->data == NULL) 740 { 741 free (w->i); 742 w->i = NULL; 743 return FALSE; 744 } 745 w->i->mapped = 0; 746 w->i->refcount = 1; 747 w->size = w->i->size = count; 748 w->data = w->i->data; 749 return bfd_get_section_contents (abfd, section, w->data, offset, count); 750 } 751 sz = section->rawsize ? section->rawsize : section->size; 752 if (offset + count > sz 753 || ! bfd_get_file_window (abfd, section->filepos + offset, count, w, 754 TRUE)) 755 return FALSE; 756 return TRUE; 757#else 758 abort (); 759#endif 760} 761 762/* This generic function can only be used in implementations where creating 763 NEW sections is disallowed. It is useful in patching existing sections 764 in read-write files, though. See other set_section_contents functions 765 to see why it doesn't work for new sections. */ 766bfd_boolean 767_bfd_generic_set_section_contents (bfd *abfd, 768 sec_ptr section, 769 const void *location, 770 file_ptr offset, 771 bfd_size_type count) 772{ 773 if (count == 0) 774 return TRUE; 775 776 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0 777 || bfd_bwrite (location, count, abfd) != count) 778 return FALSE; 779 780 return TRUE; 781} 782 783/* 784INTERNAL_FUNCTION 785 bfd_log2 786 787SYNOPSIS 788 unsigned int bfd_log2 (bfd_vma x); 789 790DESCRIPTION 791 Return the log base 2 of the value supplied, rounded up. E.g., an 792 @var{x} of 1025 returns 11. A @var{x} of 0 returns 0. 793*/ 794 795unsigned int 796bfd_log2 (bfd_vma x) 797{ 798 unsigned int result = 0; 799 800 while ((x = (x >> 1)) != 0) 801 ++result; 802 return result; 803} 804 805bfd_boolean 806bfd_generic_is_local_label_name (bfd *abfd, const char *name) 807{ 808 char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.'; 809 810 return name[0] == locals_prefix; 811} 812 813/* Can be used from / for bfd_merge_private_bfd_data to check that 814 endianness matches between input and output file. Returns 815 TRUE for a match, otherwise returns FALSE and emits an error. */ 816bfd_boolean 817_bfd_generic_verify_endian_match (bfd *ibfd, bfd *obfd) 818{ 819 if (ibfd->xvec->byteorder != obfd->xvec->byteorder 820 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN 821 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN) 822 { 823 const char *msg; 824 825 if (bfd_big_endian (ibfd)) 826 msg = _("%B: compiled for a big endian system and target is little endian"); 827 else 828 msg = _("%B: compiled for a little endian system and target is big endian"); 829 830 (*_bfd_error_handler) (msg, ibfd); 831 832 bfd_set_error (bfd_error_wrong_format); 833 return FALSE; 834 } 835 836 return TRUE; 837} 838 839/* Give a warning at runtime if someone compiles code which calls 840 old routines. */ 841 842void 843warn_deprecated (const char *what, 844 const char *file, 845 int line, 846 const char *func) 847{ 848 /* Poor man's tracking of functions we've already warned about. */ 849 static size_t mask = 0; 850 851 if (~(size_t) func & ~mask) 852 { 853 /* Note: separate sentences in order to allow 854 for translation into other languages. */ 855 if (func) 856 fprintf (stderr, _("Deprecated %s called at %s line %d in %s\n"), 857 what, file, line, func); 858 else 859 fprintf (stderr, _("Deprecated %s called\n"), what); 860 mask |= ~(size_t) func; 861 } 862} 863