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