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