1/* Assorted BFD support routines, only used internally. 2 Copyright (C) 1990-2017 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/* 31SECTION 32 Implementation details 33 34SUBSECTION 35 Internal functions 36 37DESCRIPTION 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 46bfd_boolean 47bfd_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 56bfd_boolean 57bfd_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 65void * 66bfd_nullvoidptr (bfd *ignore ATTRIBUTE_UNUSED) 67{ 68 bfd_set_error (bfd_error_invalid_operation); 69 return NULL; 70} 71 72int 73bfd_0 (bfd *ignore ATTRIBUTE_UNUSED) 74{ 75 return 0; 76} 77 78unsigned int 79bfd_0u (bfd *ignore ATTRIBUTE_UNUSED) 80{ 81 return 0; 82} 83 84long 85bfd_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 93long 94_bfd_n1 (bfd *ignore_abfd ATTRIBUTE_UNUSED) 95{ 96 bfd_set_error (bfd_error_invalid_operation); 97 return -1; 98} 99 100void 101bfd_void (bfd *ignore ATTRIBUTE_UNUSED) 102{ 103} 104 105long 106_bfd_norelocs_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, 107 asection *sec ATTRIBUTE_UNUSED) 108{ 109 return sizeof (arelent *); 110} 111 112long 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 122bfd_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 134char * 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 144int 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 154int 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 161const 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 170void * 171bfd_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 193void * 194bfd_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 209void * 210bfd_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 236void * 237bfd_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 253void * 254bfd_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 266void * 267bfd_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 280void * 281bfd_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/* 297INTERNAL_FUNCTION 298 bfd_write_bigendian_4byte_int 299 300SYNOPSIS 301 bfd_boolean bfd_write_bigendian_4byte_int (bfd *, unsigned int); 302 303DESCRIPTION 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*/ 309bfd_boolean 310bfd_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/* 330FUNCTION 331 bfd_put_size 332FUNCTION 333 bfd_get_size 334 335DESCRIPTION 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/* 409FUNCTION 410 bfd_h_put_size 411 bfd_h_get_size 412 413DESCRIPTION 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 485bfd_vma 486bfd_getb16 (const void *p) 487{ 488 const bfd_byte *addr = (const bfd_byte *) p; 489 return (addr[0] << 8) | addr[1]; 490} 491 492bfd_vma 493bfd_getl16 (const void *p) 494{ 495 const bfd_byte *addr = (const bfd_byte *) p; 496 return (addr[1] << 8) | addr[0]; 497} 498 499bfd_signed_vma 500bfd_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 506bfd_signed_vma 507bfd_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 513void 514bfd_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 521void 522bfd_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 529bfd_vma 530bfd_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 542bfd_vma 543bfd_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 555bfd_signed_vma 556bfd_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 568bfd_signed_vma 569bfd_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 581bfd_uint64_t 582bfd_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 604bfd_uint64_t 605bfd_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 628bfd_int64_t 629bfd_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 651bfd_int64_t 652bfd_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 674void 675bfd_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 684void 685bfd_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 694void 695bfd_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 712void 713bfd_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 730void 731bfd_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 750bfd_uint64_t 751bfd_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 775bfd_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 /* xgettext:c-format */ 790 (_("%B: unable to get decompressed section %A"), 791 abfd, section); 792 bfd_set_error (bfd_error_invalid_operation); 793 return FALSE; 794 } 795 796 /* We do allow reading of a section after bfd_final_link has 797 written the contents out to disk. In that situation, rawsize is 798 just a stale version of size, so ignore it. Otherwise we must be 799 reading an input section, where rawsize, if different to size, 800 is the on-disk size. */ 801 if (abfd->direction != write_direction && section->rawsize != 0) 802 sz = section->rawsize; 803 else 804 sz = section->size; 805 if (offset + count < count 806 || offset + count > sz) 807 { 808 bfd_set_error (bfd_error_invalid_operation); 809 return FALSE; 810 } 811 812 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0 813 || bfd_bread (location, count, abfd) != count) 814 return FALSE; 815 816 return TRUE; 817} 818 819bfd_boolean 820_bfd_generic_get_section_contents_in_window 821 (bfd *abfd ATTRIBUTE_UNUSED, 822 sec_ptr section ATTRIBUTE_UNUSED, 823 bfd_window *w ATTRIBUTE_UNUSED, 824 file_ptr offset ATTRIBUTE_UNUSED, 825 bfd_size_type count ATTRIBUTE_UNUSED) 826{ 827#ifdef USE_MMAP 828 bfd_size_type sz; 829 830 if (count == 0) 831 return TRUE; 832 if (abfd->xvec->_bfd_get_section_contents 833 != _bfd_generic_get_section_contents) 834 { 835 /* We don't know what changes the bfd's get_section_contents 836 method may have to make. So punt trying to map the file 837 window, and let get_section_contents do its thing. */ 838 /* @@ FIXME : If the internal window has a refcount of 1 and was 839 allocated with malloc instead of mmap, just reuse it. */ 840 bfd_free_window (w); 841 w->i = bfd_zmalloc (sizeof (bfd_window_internal)); 842 if (w->i == NULL) 843 return FALSE; 844 w->i->data = bfd_malloc (count); 845 if (w->i->data == NULL) 846 { 847 free (w->i); 848 w->i = NULL; 849 return FALSE; 850 } 851 w->i->mapped = 0; 852 w->i->refcount = 1; 853 w->size = w->i->size = count; 854 w->data = w->i->data; 855 return bfd_get_section_contents (abfd, section, w->data, offset, count); 856 } 857 if (abfd->direction != write_direction && section->rawsize != 0) 858 sz = section->rawsize; 859 else 860 sz = section->size; 861 if (offset + count > sz 862 || ! bfd_get_file_window (abfd, section->filepos + offset, count, w, 863 TRUE)) 864 return FALSE; 865 return TRUE; 866#else 867 abort (); 868#endif 869} 870 871/* This generic function can only be used in implementations where creating 872 NEW sections is disallowed. It is useful in patching existing sections 873 in read-write files, though. See other set_section_contents functions 874 to see why it doesn't work for new sections. */ 875bfd_boolean 876_bfd_generic_set_section_contents (bfd *abfd, 877 sec_ptr section, 878 const void *location, 879 file_ptr offset, 880 bfd_size_type count) 881{ 882 if (count == 0) 883 return TRUE; 884 885 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0 886 || bfd_bwrite (location, count, abfd) != count) 887 return FALSE; 888 889 return TRUE; 890} 891 892/* 893INTERNAL_FUNCTION 894 bfd_log2 895 896SYNOPSIS 897 unsigned int bfd_log2 (bfd_vma x); 898 899DESCRIPTION 900 Return the log base 2 of the value supplied, rounded up. E.g., an 901 @var{x} of 1025 returns 11. A @var{x} of 0 returns 0. 902*/ 903 904unsigned int 905bfd_log2 (bfd_vma x) 906{ 907 unsigned int result = 0; 908 909 if (x <= 1) 910 return result; 911 --x; 912 do 913 ++result; 914 while ((x >>= 1) != 0); 915 return result; 916} 917 918bfd_boolean 919bfd_generic_is_local_label_name (bfd *abfd, const char *name) 920{ 921 char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.'; 922 923 return name[0] == locals_prefix; 924} 925 926/* Give a warning at runtime if someone compiles code which calls 927 old routines. */ 928 929void 930warn_deprecated (const char *what, 931 const char *file, 932 int line, 933 const char *func) 934{ 935 /* Poor man's tracking of functions we've already warned about. */ 936 static size_t mask = 0; 937 938 if (~(size_t) func & ~mask) 939 { 940 fflush (stdout); 941 /* Note: separate sentences in order to allow 942 for translation into other languages. */ 943 if (func) 944 /* xgettext:c-format */ 945 fprintf (stderr, _("Deprecated %s called at %s line %d in %s\n"), 946 what, file, line, func); 947 else 948 fprintf (stderr, _("Deprecated %s called\n"), what); 949 fflush (stderr); 950 mask |= ~(size_t) func; 951 } 952} 953 954/* Helper function for reading uleb128 encoded data. */ 955 956bfd_vma 957read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED, 958 bfd_byte *buf, 959 unsigned int *bytes_read_ptr) 960{ 961 bfd_vma result; 962 unsigned int num_read; 963 unsigned int shift; 964 unsigned char byte; 965 966 result = 0; 967 shift = 0; 968 num_read = 0; 969 do 970 { 971 byte = bfd_get_8 (abfd, buf); 972 buf++; 973 num_read++; 974 result |= (((bfd_vma) byte & 0x7f) << shift); 975 shift += 7; 976 } 977 while (byte & 0x80); 978 *bytes_read_ptr = num_read; 979 return result; 980} 981 982/* Read in a LEB128 encoded value from ABFD starting at DATA. 983 If SIGN is true, return a signed LEB128 value. 984 If LENGTH_RETURN is not NULL, return in it the number of bytes read. 985 No bytes will be read at address END or beyond. */ 986 987bfd_vma 988safe_read_leb128 (bfd *abfd ATTRIBUTE_UNUSED, 989 bfd_byte *data, 990 unsigned int *length_return, 991 bfd_boolean sign, 992 const bfd_byte * const end) 993{ 994 bfd_vma result = 0; 995 unsigned int num_read = 0; 996 unsigned int shift = 0; 997 unsigned char byte = 0; 998 999 while (data < end) 1000 { 1001 byte = bfd_get_8 (abfd, data); 1002 data++; 1003 num_read++; 1004 1005 result |= ((bfd_vma) (byte & 0x7f)) << shift; 1006 1007 shift += 7; 1008 if ((byte & 0x80) == 0) 1009 break; 1010 } 1011 1012 if (length_return != NULL) 1013 *length_return = num_read; 1014 1015 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40)) 1016 result |= -((bfd_vma) 1 << shift); 1017 1018 return result; 1019} 1020 1021/* Helper function for reading sleb128 encoded data. */ 1022 1023bfd_signed_vma 1024read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED, 1025 bfd_byte *buf, 1026 unsigned int *bytes_read_ptr) 1027{ 1028 bfd_vma result; 1029 unsigned int shift; 1030 unsigned int num_read; 1031 unsigned char byte; 1032 1033 result = 0; 1034 shift = 0; 1035 num_read = 0; 1036 do 1037 { 1038 byte = bfd_get_8 (abfd, buf); 1039 buf ++; 1040 num_read ++; 1041 result |= (((bfd_vma) byte & 0x7f) << shift); 1042 shift += 7; 1043 } 1044 while (byte & 0x80); 1045 if (shift < 8 * sizeof (result) && (byte & 0x40)) 1046 result |= (((bfd_vma) -1) << shift); 1047 *bytes_read_ptr = num_read; 1048 return result; 1049} 1050 1051bfd_boolean 1052_bfd_generic_init_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED, 1053 asection *isec ATTRIBUTE_UNUSED, 1054 bfd *obfd ATTRIBUTE_UNUSED, 1055 asection *osec ATTRIBUTE_UNUSED, 1056 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 1057{ 1058 return TRUE; 1059} 1060