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