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