bfd/libbfd.c

   1 /* Assorted BFD support routines, only used internally.
   2    Copyright (C) 1990-2024 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 "elf-bfd.h"
  25 #include "libbfd.h"
  26 #include "objalloc.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 bool
  46 _bfd_bool_bfd_false (bfd *abfd ATTRIBUTE_UNUSED)
  47 {
  48   return false;
  49 }
  50
  51 bool
  52 _bfd_bool_bfd_asymbol_false (bfd *abfd ATTRIBUTE_UNUSED,
  53                              asymbol *sym ATTRIBUTE_UNUSED)
  54 {
  55   return false;
  56 }
  57
  58 /* A routine which is used in target vectors for unsupported
  59    operations.  */
  60
  61 bool
  62 _bfd_bool_bfd_false_error (bfd *ignore ATTRIBUTE_UNUSED)
  63 {
  64   bfd_set_error (bfd_error_invalid_operation);
  65   return false;
  66 }
  67
  68 bool
  69 _bfd_bool_bfd_link_false_error (bfd *abfd,
  70                                 struct bfd_link_info *info ATTRIBUTE_UNUSED)
  71 {
  72   return _bfd_bool_bfd_false_error (abfd);
  73 }
  74
  75 /* A routine which is used in target vectors for supported operations
  76    which do not actually do anything.  */
  77
  78 bool
  79 _bfd_bool_bfd_true (bfd *ignore ATTRIBUTE_UNUSED)
  80 {
  81   return true;
  82 }
  83
  84 bool
  85 _bfd_bool_bfd_link_true (bfd *abfd ATTRIBUTE_UNUSED,
  86                          struct bfd_link_info *info ATTRIBUTE_UNUSED)
  87 {
  88   return true;
  89 }
  90
  91 bool
  92 _bfd_bool_bfd_bfd_true (bfd *ibfd ATTRIBUTE_UNUSED,
  93                         bfd *obfd ATTRIBUTE_UNUSED)
  94 {
  95   return true;
  96 }
  97
  98 bool
  99 _bfd_bool_bfd_uint_true (bfd *abfd ATTRIBUTE_UNUSED,
 100                          unsigned int flags ATTRIBUTE_UNUSED)
 101 {
 102   return true;
 103 }
 104
 105 bool
 106 _bfd_bool_bfd_asection_bfd_asection_true (bfd *ibfd ATTRIBUTE_UNUSED,
 107                                           asection *isec ATTRIBUTE_UNUSED,
 108                                           bfd *obfd ATTRIBUTE_UNUSED,
 109                                           asection *osec ATTRIBUTE_UNUSED)
 110 {
 111   return true;
 112 }
 113
 114 bool
 115 _bfd_bool_bfd_asymbol_bfd_asymbol_true (bfd *ibfd ATTRIBUTE_UNUSED,
 116                                         asymbol *isym ATTRIBUTE_UNUSED,
 117                                         bfd *obfd ATTRIBUTE_UNUSED,
 118                                         asymbol *osym ATTRIBUTE_UNUSED)
 119 {
 120   return true;
 121 }
 122
 123 bool
 124 _bfd_bool_bfd_ptr_true (bfd *abfd ATTRIBUTE_UNUSED,
 125                         void *ptr ATTRIBUTE_UNUSED)
 126 {
 127   return true;
 128 }
 129
 130 /* A routine which is used in target vectors for unsupported
 131    operations which return a pointer value.  */
 132
 133 void *
 134 _bfd_ptr_bfd_null_error (bfd *ignore ATTRIBUTE_UNUSED)
 135 {
 136   bfd_set_error (bfd_error_invalid_operation);
 137   return NULL;
 138 }
 139
 140 int
 141 _bfd_int_bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
 142 {
 143   return 0;
 144 }
 145
 146 unsigned int
 147 _bfd_uint_bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
 148 {
 149    return 0;
 150 }
 151
 152 long
 153 _bfd_long_bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
 154 {
 155   return 0;
 156 }
 157
 158 /* A routine which is used in target vectors for unsupported
 159    operations which return -1 on error.  */
 160
 161 long
 162 _bfd_long_bfd_n1_error (bfd *ignore_abfd ATTRIBUTE_UNUSED)
 163 {
 164   bfd_set_error (bfd_error_invalid_operation);
 165   return -1;
 166 }
 167
 168 void
 169 _bfd_void_bfd (bfd *ignore ATTRIBUTE_UNUSED)
 170 {
 171 }
 172
 173 void
 174 _bfd_void_bfd_link (bfd *abfd ATTRIBUTE_UNUSED,
 175                     struct bfd_link_info *info ATTRIBUTE_UNUSED)
 176 {
 177 }
 178
 179 void
 180 _bfd_void_bfd_asection (bfd *abfd ATTRIBUTE_UNUSED,
 181                         asection *sec ATTRIBUTE_UNUSED)
 182 {
 183 }
 184
 185 long
 186 _bfd_norelocs_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
 187                                      asection *sec ATTRIBUTE_UNUSED)
 188 {
 189   return sizeof (arelent *);
 190 }
 191
 192 long
 193 _bfd_norelocs_canonicalize_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 194                                   asection *sec ATTRIBUTE_UNUSED,
 195                                   arelent **relptr,
 196                                   asymbol **symbols ATTRIBUTE_UNUSED)
 197 {
 198   *relptr = NULL;
 199   return 0;
 200 }
 201
 202 void
 203 _bfd_norelocs_set_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 204                          asection *sec ATTRIBUTE_UNUSED,
 205                          arelent **relptr ATTRIBUTE_UNUSED,
 206                          unsigned int count ATTRIBUTE_UNUSED)
 207 {
 208   /* Do nothing.  */
 209 }
 210
 211 bool
 212 _bfd_nocore_core_file_matches_executable_p
 213   (bfd *ignore_core_bfd ATTRIBUTE_UNUSED,
 214    bfd *ignore_exec_bfd ATTRIBUTE_UNUSED)
 215 {
 216   bfd_set_error (bfd_error_invalid_operation);
 217   return false;
 218 }
 219
 220 /* Routine to handle core_file_failing_command entry point for targets
 221    without core file support.  */
 222
 223 char *
 224 _bfd_nocore_core_file_failing_command (bfd *ignore_abfd ATTRIBUTE_UNUSED)
 225 {
 226   bfd_set_error (bfd_error_invalid_operation);
 227   return NULL;
 228 }
 229
 230 /* Routine to handle core_file_failing_signal entry point for targets
 231    without core file support.  */
 232
 233 int
 234 _bfd_nocore_core_file_failing_signal (bfd *ignore_abfd ATTRIBUTE_UNUSED)
 235 {
 236   bfd_set_error (bfd_error_invalid_operation);
 237   return 0;
 238 }
 239
 240 /* Routine to handle the core_file_pid entry point for targets without
 241    core file support.  */
 242
 243 int
 244 _bfd_nocore_core_file_pid (bfd *ignore_abfd ATTRIBUTE_UNUSED)
 245 {
 246   bfd_set_error (bfd_error_invalid_operation);
 247   return 0;
 248 }
 249
 250 bfd_cleanup
 251 _bfd_dummy_target (bfd *ignore_abfd ATTRIBUTE_UNUSED)
 252 {
 253   bfd_set_error (bfd_error_wrong_format);
 254   return 0;
 255 }
 256 \f
 257 /* Allocate memory using malloc.  */
 258
 259 #ifndef SSIZE_MAX
 260 #define SSIZE_MAX ((size_t) -1 >> 1)
 261 #endif
 262
 263 /*
 264 INTERNAL_FUNCTION
 265         bfd_malloc
 266
 267 SYNOPSIS
 268         void *bfd_malloc (bfd_size_type {*size*});
 269
 270 DESCRIPTION
 271         Returns a pointer to an allocated block of memory that is at least
 272         SIZE bytes long.  If SIZE is 0 then it will be treated as if it were
 273         1.  If SIZE is too big then NULL will be returned.
 274
 275         Returns NULL upon error and sets bfd_error.
 276 */
 277 void *
 278 bfd_malloc (bfd_size_type size)
 279 {
 280   void *ptr;
 281   size_t sz = (size_t) size;
 282
 283   if (size != sz
 284       /* This is to pacify memory checkers like valgrind.  */
 285       || sz > SSIZE_MAX)
 286     {
 287       bfd_set_error (bfd_error_no_memory);
 288       return NULL;
 289     }
 290
 291   ptr = malloc (sz ? sz : 1);
 292   if (ptr == NULL)
 293     bfd_set_error (bfd_error_no_memory);
 294
 295   return ptr;
 296 }
 297
 298 /*
 299 INTERNAL_FUNCTION
 300         bfd_realloc
 301
 302 SYNOPSIS
 303         void *bfd_realloc (void *{*mem*}, bfd_size_type {*size*});
 304
 305 DESCRIPTION
 306         Returns a pointer to an allocated block of memory that is at least
 307         SIZE bytes long.  If SIZE is 0 then it will be treated as if it were
 308         1.  If SIZE is too big then NULL will be returned.
 309
 310         If MEM is not NULL then it must point to an allocated block of memory.
 311         If this block is large enough then MEM may be used as the return
 312         value for this function, but this is not guaranteed.
 313
 314         If MEM is not returned then the first N bytes in the returned block
 315         will be identical to the first N bytes in region pointed to by MEM,
 316         where N is the lessor of SIZE and the length of the region of memory
 317         currently addressed by MEM.
 318
 319         Returns NULL upon error and sets bfd_error.
 320 */
 321 void *
 322 bfd_realloc (void *ptr, bfd_size_type size)
 323 {
 324   void *ret;
 325   size_t sz = (size_t) size;
 326
 327   if (ptr == NULL)
 328     return bfd_malloc (size);
 329
 330   if (size != sz
 331       /* This is to pacify memory checkers like valgrind.  */
 332       || sz > SSIZE_MAX)
 333     {
 334       bfd_set_error (bfd_error_no_memory);
 335       return NULL;
 336     }
 337
 338   /* The behaviour of realloc(0) is implementation defined,
 339      but for this function we always allocate memory.  */
 340   ret = realloc (ptr, sz ? sz : 1);
 341
 342   if (ret == NULL)
 343     bfd_set_error (bfd_error_no_memory);
 344
 345   return ret;
 346 }
 347
 348 /*
 349 INTERNAL_FUNCTION
 350         bfd_realloc_or_free
 351
 352 SYNOPSIS
 353         void *bfd_realloc_or_free (void *{*mem*}, bfd_size_type {*size*});
 354
 355 DESCRIPTION
 356         Returns a pointer to an allocated block of memory that is at least
 357         SIZE bytes long.  If SIZE is 0 then no memory will be allocated,
 358         MEM will be freed, and NULL will be returned.  This will not cause
 359         bfd_error to be set.
 360
 361         If SIZE is too big then NULL will be returned and bfd_error will be
 362         set.
 363
 364         If MEM is not NULL then it must point to an allocated block of memory.
 365         If this block is large enough then MEM may be used as the return
 366         value for this function, but this is not guaranteed.
 367
 368         If MEM is not returned then the first N bytes in the returned block
 369         will be identical to the first N bytes in region pointed to by MEM,
 370         where N is the lessor of SIZE and the length of the region of memory
 371         currently addressed by MEM.
 372 */
 373 void *
 374 bfd_realloc_or_free (void *ptr, bfd_size_type size)
 375 {
 376   void *ret;
 377
 378   /* The behaviour of realloc(0) is implementation defined, but
 379      for this function we treat it is always freeing the memory.  */
 380   if (size == 0)
 381     {
 382       free (ptr);
 383       return NULL;
 384     }
 385
 386   ret = bfd_realloc (ptr, size);
 387   if (ret == NULL)
 388     free (ptr);
 389
 390   return ret;
 391 }
 392
 393 /*
 394 INTERNAL_FUNCTION
 395         bfd_zmalloc
 396
 397 SYNOPSIS
 398         void *bfd_zmalloc (bfd_size_type {*size*});
 399
 400 DESCRIPTION
 401         Returns a pointer to an allocated block of memory that is at least
 402         SIZE bytes long.  If SIZE is 0 then it will be treated as if it were
 403         1.  If SIZE is too big then NULL will be returned.
 404
 405         Returns NULL upon error and sets bfd_error.
 406
 407         If NULL is not returned then the allocated block of memory will
 408         have been cleared.
 409 */
 410 void *
 411 bfd_zmalloc (bfd_size_type size)
 412 {
 413   void *ptr = bfd_malloc (size);
 414
 415   if (ptr != NULL)
 416     memset (ptr, 0, size ? (size_t) size : 1);
 417
 418   return ptr;
 419 }
 420
 421 /*
 422 FUNCTION
 423         bfd_alloc
 424
 425 SYNOPSIS
 426         void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
 427
 428 DESCRIPTION
 429         Allocate a block of @var{wanted} bytes of memory attached to
 430         <<abfd>> and return a pointer to it.
 431 */
 432
 433 void *
 434 bfd_alloc (bfd *abfd, bfd_size_type size)
 435 {
 436   void *ret;
 437   unsigned long ul_size = (unsigned long) size;
 438
 439   if (size != ul_size
 440       /* Note - although objalloc_alloc takes an unsigned long as its
 441          argument, internally the size is treated as a signed long.  This can
 442          lead to problems where, for example, a request to allocate -1 bytes
 443          can result in just 1 byte being allocated, rather than
 444          ((unsigned long) -1) bytes.  Also memory checkers will often
 445          complain about attempts to allocate a negative amount of memory.
 446          So to stop these problems we fail if the size is negative.  */
 447       || ((signed long) ul_size) < 0)
 448     {
 449       bfd_set_error (bfd_error_no_memory);
 450       return NULL;
 451     }
 452
 453   ret = objalloc_alloc ((struct objalloc *) abfd->memory, ul_size);
 454   if (ret == NULL)
 455     bfd_set_error (bfd_error_no_memory);
 456   else
 457     abfd->alloc_size += size;
 458   return ret;
 459 }
 460
 461 /*
 462 FUNCTION
 463         bfd_zalloc
 464
 465 SYNOPSIS
 466         void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
 467
 468 DESCRIPTION
 469         Allocate a block of @var{wanted} bytes of zeroed memory
 470         attached to <<abfd>> and return a pointer to it.
 471 */
 472
 473 void *
 474 bfd_zalloc (bfd *abfd, bfd_size_type size)
 475 {
 476   void *res;
 477
 478   res = bfd_alloc (abfd, size);
 479   if (res)
 480     memset (res, 0, (size_t) size);
 481   return res;
 482 }
 483
 484 /*
 485 FUNCTION
 486         bfd_release
 487
 488 SYNOPSIS
 489         void bfd_release (bfd *, void *);
 490
 491 DESCRIPTION
 492         Free a block allocated for a BFD.
 493         Note: Also frees all more recently allocated blocks!
 494 */
 495
 496 void
 497 bfd_release (bfd *abfd, void *block)
 498 {
 499   objalloc_free_block ((struct objalloc *) abfd->memory, block);
 500 }
 501
 502 /*
 503 INTERNAL_FUNCTION
 504         bfd_write_bigendian_4byte_int
 505
 506 SYNOPSIS
 507         bool bfd_write_bigendian_4byte_int (bfd *, unsigned int);
 508
 509 DESCRIPTION
 510         Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
 511         endian order regardless of what else is going on.  This is useful in
 512         archives.
 513
 514 */
 515 bool
 516 bfd_write_bigendian_4byte_int (bfd *abfd, unsigned int i)
 517 {
 518   bfd_byte buffer[4];
 519   bfd_putb32 (i, buffer);
 520   return bfd_write (buffer, 4, abfd) == 4;
 521 }
 522
 523 \f
 524 /** The do-it-yourself (byte) sex-change kit */
 525
 526 /* The middle letter e.g. get<b>short indicates Big or Little endian
 527    target machine.  It doesn't matter what the byte order of the host
 528    machine is; these routines work for either.  */
 529
 530 /* FIXME: Should these take a count argument?
 531    Answer (gnu@cygnus.com):  No, but perhaps they should be inline
 532                              functions in swap.h #ifdef __GNUC__.
 533                              Gprof them later and find out.  */
 534
 535 /*
 536 FUNCTION
 537         bfd_put_size
 538 FUNCTION
 539         bfd_get_size
 540
 541 DESCRIPTION
 542         These macros as used for reading and writing raw data in
 543         sections; each access (except for bytes) is vectored through
 544         the target format of the BFD and mangled accordingly. The
 545         mangling performs any necessary endian translations and
 546         removes alignment restrictions.  Note that types accepted and
 547         returned by these macros are identical so they can be swapped
 548         around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
 549         to either <<bfd_get_32>> or <<bfd_get_64>>.
 550
 551         In the put routines, @var{val} must be a <<bfd_vma>>.  If we are on a
 552         system without prototypes, the caller is responsible for making
 553         sure that is true, with a cast if necessary.  We don't cast
 554         them in the macro definitions because that would prevent <<lint>>
 555         or <<gcc -Wall>> from detecting sins such as passing a pointer.
 556         To detect calling these with less than a <<bfd_vma>>, use
 557         <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
 558
 559 .
 560 .{* Byte swapping macros for user section data.  *}
 561 .
 562 .#define bfd_put_8(abfd, val, ptr) \
 563 .  ((void) (*((bfd_byte *) (ptr)) = (val) & 0xff))
 564 .#define bfd_put_signed_8 \
 565 .  bfd_put_8
 566 .#define bfd_get_8(abfd, ptr) \
 567 .  ((bfd_vma) *(const bfd_byte *) (ptr) & 0xff)
 568 .#define bfd_get_signed_8(abfd, ptr) \
 569 .  ((((bfd_signed_vma) *(const bfd_byte *) (ptr) & 0xff) ^ 0x80) - 0x80)
 570 .
 571 .#define bfd_put_16(abfd, val, ptr) \
 572 .  BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))
 573 .#define bfd_put_signed_16 \
 574 .  bfd_put_16
 575 .#define bfd_get_16(abfd, ptr) \
 576 .  BFD_SEND (abfd, bfd_getx16, (ptr))
 577 .#define bfd_get_signed_16(abfd, ptr) \
 578 .  BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
 579 .
 580 .#define bfd_put_24(abfd, val, ptr) \
 581 .  do                                   \
 582 .    if (bfd_big_endian (abfd))         \
 583 .      bfd_putb24 ((val), (ptr));       \
 584 .    else                               \
 585 .      bfd_putl24 ((val), (ptr));       \
 586 .  while (0)
 587 .
 588 .bfd_vma bfd_getb24 (const void *p);
 589 .bfd_vma bfd_getl24 (const void *p);
 590 .
 591 .#define bfd_get_24(abfd, ptr) \
 592 .  (bfd_big_endian (abfd) ? bfd_getb24 (ptr) : bfd_getl24 (ptr))
 593 .
 594 .#define bfd_put_32(abfd, val, ptr) \
 595 .  BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))
 596 .#define bfd_put_signed_32 \
 597 .  bfd_put_32
 598 .#define bfd_get_32(abfd, ptr) \
 599 .  BFD_SEND (abfd, bfd_getx32, (ptr))
 600 .#define bfd_get_signed_32(abfd, ptr) \
 601 .  BFD_SEND (abfd, bfd_getx_signed_32, (ptr))
 602 .
 603 .#define bfd_put_64(abfd, val, ptr) \
 604 .  BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))
 605 .#define bfd_put_signed_64 \
 606 .  bfd_put_64
 607 .#define bfd_get_64(abfd, ptr) \
 608 .  BFD_SEND (abfd, bfd_getx64, (ptr))
 609 .#define bfd_get_signed_64(abfd, ptr) \
 610 .  BFD_SEND (abfd, bfd_getx_signed_64, (ptr))
 611 .
 612 .#define bfd_get(bits, abfd, ptr)                       \
 613 .  ((bits) == 8 ? bfd_get_8 (abfd, ptr)                 \
 614 .   : (bits) == 16 ? bfd_get_16 (abfd, ptr)             \
 615 .   : (bits) == 32 ? bfd_get_32 (abfd, ptr)             \
 616 .   : (bits) == 64 ? bfd_get_64 (abfd, ptr)             \
 617 .   : (abort (), (bfd_vma) - 1))
 618 .
 619 .#define bfd_put(bits, abfd, val, ptr)                  \
 620 .  ((bits) == 8 ? bfd_put_8  (abfd, val, ptr)           \
 621 .   : (bits) == 16 ? bfd_put_16 (abfd, val, ptr)        \
 622 .   : (bits) == 32 ? bfd_put_32 (abfd, val, ptr)        \
 623 .   : (bits) == 64 ? bfd_put_64 (abfd, val, ptr)        \
 624 .   : (abort (), (void) 0))
 625 .
 626 */
 627
 628 /*
 629 FUNCTION
 630         bfd_h_put_size
 631         bfd_h_get_size
 632
 633 DESCRIPTION
 634         These macros have the same function as their <<bfd_get_x>>
 635         brethren, except that they are used for removing information
 636         for the header records of object files. Believe it or not,
 637         some object files keep their header records in big endian
 638         order and their data in little endian order.
 639 .
 640 .{* Byte swapping macros for file header data.  *}
 641 .
 642 .#define bfd_h_put_8(abfd, val, ptr) \
 643 .  bfd_put_8 (abfd, val, ptr)
 644 .#define bfd_h_put_signed_8(abfd, val, ptr) \
 645 .  bfd_put_8 (abfd, val, ptr)
 646 .#define bfd_h_get_8(abfd, ptr) \
 647 .  bfd_get_8 (abfd, ptr)
 648 .#define bfd_h_get_signed_8(abfd, ptr) \
 649 .  bfd_get_signed_8 (abfd, ptr)
 650 .
 651 .#define bfd_h_put_16(abfd, val, ptr) \
 652 .  BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
 653 .#define bfd_h_put_signed_16 \
 654 .  bfd_h_put_16
 655 .#define bfd_h_get_16(abfd, ptr) \
 656 .  BFD_SEND (abfd, bfd_h_getx16, (ptr))
 657 .#define bfd_h_get_signed_16(abfd, ptr) \
 658 .  BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
 659 .
 660 .#define bfd_h_put_32(abfd, val, ptr) \
 661 .  BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
 662 .#define bfd_h_put_signed_32 \
 663 .  bfd_h_put_32
 664 .#define bfd_h_get_32(abfd, ptr) \
 665 .  BFD_SEND (abfd, bfd_h_getx32, (ptr))
 666 .#define bfd_h_get_signed_32(abfd, ptr) \
 667 .  BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
 668 .
 669 .#define bfd_h_put_64(abfd, val, ptr) \
 670 .  BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
 671 .#define bfd_h_put_signed_64 \
 672 .  bfd_h_put_64
 673 .#define bfd_h_get_64(abfd, ptr) \
 674 .  BFD_SEND (abfd, bfd_h_getx64, (ptr))
 675 .#define bfd_h_get_signed_64(abfd, ptr) \
 676 .  BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
 677 .
 678 .{* Aliases for the above, which should eventually go away.  *}
 679 .
 680 .#define H_PUT_64  bfd_h_put_64
 681 .#define H_PUT_32  bfd_h_put_32
 682 .#define H_PUT_16  bfd_h_put_16
 683 .#define H_PUT_8   bfd_h_put_8
 684 .#define H_PUT_S64 bfd_h_put_signed_64
 685 .#define H_PUT_S32 bfd_h_put_signed_32
 686 .#define H_PUT_S16 bfd_h_put_signed_16
 687 .#define H_PUT_S8  bfd_h_put_signed_8
 688 .#define H_GET_64  bfd_h_get_64
 689 .#define H_GET_32  bfd_h_get_32
 690 .#define H_GET_16  bfd_h_get_16
 691 .#define H_GET_8   bfd_h_get_8
 692 .#define H_GET_S64 bfd_h_get_signed_64
 693 .#define H_GET_S32 bfd_h_get_signed_32
 694 .#define H_GET_S16 bfd_h_get_signed_16
 695 .#define H_GET_S8  bfd_h_get_signed_8
 696 .
 697 .*/
 698
 699 /* Sign extension to bfd_signed_vma.  */
 700 #define COERCE16(x) (((bfd_vma) (x) ^ 0x8000) - 0x8000)
 701 #define COERCE32(x) (((bfd_vma) (x) ^ 0x80000000) - 0x80000000)
 702 #define COERCE64(x) \
 703   (((uint64_t) (x) ^ ((uint64_t) 1 << 63)) - ((uint64_t) 1 << 63))
 704
 705 /*
 706 FUNCTION
 707         Byte swapping routines.
 708
 709 SYNOPSIS
 710         uint64_t bfd_getb64 (const void *);
 711         uint64_t bfd_getl64 (const void *);
 712         int64_t bfd_getb_signed_64 (const void *);
 713         int64_t bfd_getl_signed_64 (const void *);
 714         bfd_vma bfd_getb32 (const void *);
 715         bfd_vma bfd_getl32 (const void *);
 716         bfd_signed_vma bfd_getb_signed_32 (const void *);
 717         bfd_signed_vma bfd_getl_signed_32 (const void *);
 718         bfd_vma bfd_getb16 (const void *);
 719         bfd_vma bfd_getl16 (const void *);
 720         bfd_signed_vma bfd_getb_signed_16 (const void *);
 721         bfd_signed_vma bfd_getl_signed_16 (const void *);
 722         void bfd_putb64 (uint64_t, void *);
 723         void bfd_putl64 (uint64_t, void *);
 724         void bfd_putb32 (bfd_vma, void *);
 725         void bfd_putl32 (bfd_vma, void *);
 726         void bfd_putb24 (bfd_vma, void *);
 727         void bfd_putl24 (bfd_vma, void *);
 728         void bfd_putb16 (bfd_vma, void *);
 729         void bfd_putl16 (bfd_vma, void *);
 730         uint64_t bfd_get_bits (const void *, int, bool);
 731         void bfd_put_bits (uint64_t, void *, int, bool);
 732
 733 DESCRIPTION
 734         Read and write integers in a particular endian order.  getb
 735         and putb functions handle big-endian, getl and putl handle
 736         little-endian.  bfd_get_bits and bfd_put_bits specify
 737         big-endian by passing TRUE in the last parameter,
 738         little-endian by passing FALSE.
 739 */
 740
 741 bfd_vma
 742 bfd_getb16 (const void *p)
 743 {
 744   const bfd_byte *addr = (const bfd_byte *) p;
 745   return (addr[0] << 8) | addr[1];
 746 }
 747
 748 bfd_vma
 749 bfd_getl16 (const void *p)
 750 {
 751   const bfd_byte *addr = (const bfd_byte *) p;
 752   return (addr[1] << 8) | addr[0];
 753 }
 754
 755 bfd_signed_vma
 756 bfd_getb_signed_16 (const void *p)
 757 {
 758   const bfd_byte *addr = (const bfd_byte *) p;
 759   return COERCE16 ((addr[0] << 8) | addr[1]);
 760 }
 761
 762 bfd_signed_vma
 763 bfd_getl_signed_16 (const void *p)
 764 {
 765   const bfd_byte *addr = (const bfd_byte *) p;
 766   return COERCE16 ((addr[1] << 8) | addr[0]);
 767 }
 768
 769 void
 770 bfd_putb16 (bfd_vma data, void *p)
 771 {
 772   bfd_byte *addr = (bfd_byte *) p;
 773   addr[0] = (data >> 8) & 0xff;
 774   addr[1] = data & 0xff;
 775 }
 776
 777 void
 778 bfd_putl16 (bfd_vma data, void *p)
 779 {
 780   bfd_byte *addr = (bfd_byte *) p;
 781   addr[0] = data & 0xff;
 782   addr[1] = (data >> 8) & 0xff;
 783 }
 784
 785 void
 786 bfd_putb24 (bfd_vma data, void *p)
 787 {
 788   bfd_byte *addr = (bfd_byte *) p;
 789   addr[0] = (data >> 16) & 0xff;
 790   addr[1] = (data >> 8) & 0xff;
 791   addr[2] = data & 0xff;
 792 }
 793
 794 void
 795 bfd_putl24 (bfd_vma data, void *p)
 796 {
 797   bfd_byte *addr = (bfd_byte *) p;
 798   addr[0] = data & 0xff;
 799   addr[1] = (data >> 8) & 0xff;
 800   addr[2] = (data >> 16) & 0xff;
 801 }
 802
 803 bfd_vma
 804 bfd_getb24 (const void *p)
 805 {
 806   const bfd_byte *addr = (const bfd_byte *) p;
 807   uint32_t v;
 808
 809   v =  (uint32_t) addr[0] << 16;
 810   v |= (uint32_t) addr[1] << 8;
 811   v |= (uint32_t) addr[2];
 812   return v;
 813 }
 814
 815 bfd_vma
 816 bfd_getl24 (const void *p)
 817 {
 818   const bfd_byte *addr = (const bfd_byte *) p;
 819   uint32_t v;
 820
 821   v = (uint32_t) addr[0];
 822   v |= (uint32_t) addr[1] << 8;
 823   v |= (uint32_t) addr[2] << 16;
 824   return v;
 825 }
 826
 827 bfd_vma
 828 bfd_getb32 (const void *p)
 829 {
 830   const bfd_byte *addr = (const bfd_byte *) p;
 831   uint32_t v;
 832
 833   v = (uint32_t) addr[0] << 24;
 834   v |= (uint32_t) addr[1] << 16;
 835   v |= (uint32_t) addr[2] << 8;
 836   v |= (uint32_t) addr[3];
 837   return v;
 838 }
 839
 840 bfd_vma
 841 bfd_getl32 (const void *p)
 842 {
 843   const bfd_byte *addr = (const bfd_byte *) p;
 844   uint32_t v;
 845
 846   v = (uint32_t) addr[0];
 847   v |= (uint32_t) addr[1] << 8;
 848   v |= (uint32_t) addr[2] << 16;
 849   v |= (uint32_t) addr[3] << 24;
 850   return v;
 851 }
 852
 853 bfd_signed_vma
 854 bfd_getb_signed_32 (const void *p)
 855 {
 856   const bfd_byte *addr = (const bfd_byte *) p;
 857   uint32_t v;
 858
 859   v = (uint32_t) addr[0] << 24;
 860   v |= (uint32_t) addr[1] << 16;
 861   v |= (uint32_t) addr[2] << 8;
 862   v |= (uint32_t) addr[3];
 863   return COERCE32 (v);
 864 }
 865
 866 bfd_signed_vma
 867 bfd_getl_signed_32 (const void *p)
 868 {
 869   const bfd_byte *addr = (const bfd_byte *) p;
 870   uint32_t v;
 871
 872   v = (uint32_t) addr[0];
 873   v |= (uint32_t) addr[1] << 8;
 874   v |= (uint32_t) addr[2] << 16;
 875   v |= (uint32_t) addr[3] << 24;
 876   return COERCE32 (v);
 877 }
 878
 879 uint64_t
 880 bfd_getb64 (const void *p)
 881 {
 882   const bfd_byte *addr = (const bfd_byte *) p;
 883   uint64_t v;
 884
 885   v  = addr[0]; v <<= 8;
 886   v |= addr[1]; v <<= 8;
 887   v |= addr[2]; v <<= 8;
 888   v |= addr[3]; v <<= 8;
 889   v |= addr[4]; v <<= 8;
 890   v |= addr[5]; v <<= 8;
 891   v |= addr[6]; v <<= 8;
 892   v |= addr[7];
 893
 894   return v;
 895 }
 896
 897 uint64_t
 898 bfd_getl64 (const void *p)
 899 {
 900   const bfd_byte *addr = (const bfd_byte *) p;
 901   uint64_t v;
 902
 903   v  = addr[7]; v <<= 8;
 904   v |= addr[6]; v <<= 8;
 905   v |= addr[5]; v <<= 8;
 906   v |= addr[4]; v <<= 8;
 907   v |= addr[3]; v <<= 8;
 908   v |= addr[2]; v <<= 8;
 909   v |= addr[1]; v <<= 8;
 910   v |= addr[0];
 911
 912   return v;
 913 }
 914
 915 int64_t
 916 bfd_getb_signed_64 (const void *p)
 917 {
 918   const bfd_byte *addr = (const bfd_byte *) p;
 919   uint64_t v;
 920
 921   v  = addr[0]; v <<= 8;
 922   v |= addr[1]; v <<= 8;
 923   v |= addr[2]; v <<= 8;
 924   v |= addr[3]; v <<= 8;
 925   v |= addr[4]; v <<= 8;
 926   v |= addr[5]; v <<= 8;
 927   v |= addr[6]; v <<= 8;
 928   v |= addr[7];
 929
 930   return COERCE64 (v);
 931 }
 932
 933 int64_t
 934 bfd_getl_signed_64 (const void *p)
 935 {
 936   const bfd_byte *addr = (const bfd_byte *) p;
 937   uint64_t v;
 938
 939   v  = addr[7]; v <<= 8;
 940   v |= addr[6]; v <<= 8;
 941   v |= addr[5]; v <<= 8;
 942   v |= addr[4]; v <<= 8;
 943   v |= addr[3]; v <<= 8;
 944   v |= addr[2]; v <<= 8;
 945   v |= addr[1]; v <<= 8;
 946   v |= addr[0];
 947
 948   return COERCE64 (v);
 949 }
 950
 951 void
 952 bfd_putb32 (bfd_vma data, void *p)
 953 {
 954   bfd_byte *addr = (bfd_byte *) p;
 955   addr[0] = (data >> 24) & 0xff;
 956   addr[1] = (data >> 16) & 0xff;
 957   addr[2] = (data >>  8) & 0xff;
 958   addr[3] = data & 0xff;
 959 }
 960
 961 void
 962 bfd_putl32 (bfd_vma data, void *p)
 963 {
 964   bfd_byte *addr = (bfd_byte *) p;
 965   addr[0] = data & 0xff;
 966   addr[1] = (data >>  8) & 0xff;
 967   addr[2] = (data >> 16) & 0xff;
 968   addr[3] = (data >> 24) & 0xff;
 969 }
 970
 971 void
 972 bfd_putb64 (uint64_t data, void *p)
 973 {
 974   bfd_byte *addr = (bfd_byte *) p;
 975   addr[0] = (data >> (7*8)) & 0xff;
 976   addr[1] = (data >> (6*8)) & 0xff;
 977   addr[2] = (data >> (5*8)) & 0xff;
 978   addr[3] = (data >> (4*8)) & 0xff;
 979   addr[4] = (data >> (3*8)) & 0xff;
 980   addr[5] = (data >> (2*8)) & 0xff;
 981   addr[6] = (data >> (1*8)) & 0xff;
 982   addr[7] = (data >> (0*8)) & 0xff;
 983 }
 984
 985 void
 986 bfd_putl64 (uint64_t data, void *p)
 987 {
 988   bfd_byte *addr = (bfd_byte *) p;
 989   addr[7] = (data >> (7*8)) & 0xff;
 990   addr[6] = (data >> (6*8)) & 0xff;
 991   addr[5] = (data >> (5*8)) & 0xff;
 992   addr[4] = (data >> (4*8)) & 0xff;
 993   addr[3] = (data >> (3*8)) & 0xff;
 994   addr[2] = (data >> (2*8)) & 0xff;
 995   addr[1] = (data >> (1*8)) & 0xff;
 996   addr[0] = (data >> (0*8)) & 0xff;
 997 }
 998
 999 void
1000 bfd_put_bits (uint64_t data, void *p, int bits, bool big_p)
1001 {
1002   bfd_byte *addr = (bfd_byte *) p;
1003   int i;
1004   int bytes;
1005
1006   if (bits % 8 != 0)
1007     abort ();
1008
1009   bytes = bits / 8;
1010   for (i = 0; i < bytes; i++)
1011     {
1012       int addr_index = big_p ? bytes - i - 1 : i;
1013
1014       addr[addr_index] = data & 0xff;
1015       data >>= 8;
1016     }
1017 }
1018
1019 uint64_t
1020 bfd_get_bits (const void *p, int bits, bool big_p)
1021 {
1022   const bfd_byte *addr = (const bfd_byte *) p;
1023   uint64_t data;
1024   int i;
1025   int bytes;
1026
1027   if (bits % 8 != 0)
1028     abort ();
1029
1030   data = 0;
1031   bytes = bits / 8;
1032   for (i = 0; i < bytes; i++)
1033     {
1034       int addr_index = big_p ? i : bytes - i - 1;
1035
1036       data = (data << 8) | addr[addr_index];
1037     }
1038
1039   return data;
1040 }
1041 \f
1042 #ifdef USE_MMAP
1043 /* Allocate a page to track mmapped memory and return the page and
1044    the first entry.  Return NULL if mmap fails.  */
1045
1046 static struct bfd_mmapped *
1047 bfd_allocate_mmapped_page (bfd *abfd, struct bfd_mmapped_entry **entry)
1048 {
1049   struct bfd_mmapped * mmapped
1050     = (struct bfd_mmapped *) mmap (NULL, _bfd_pagesize,
1051                                    PROT_READ | PROT_WRITE,
1052                                    MAP_PRIVATE | MAP_ANONYMOUS,
1053                                    -1, 0);
1054   if (mmapped == MAP_FAILED)
1055     return NULL;
1056
1057   mmapped->next = abfd->mmapped;
1058   mmapped->max_entry
1059     = ((_bfd_pagesize - offsetof (struct bfd_mmapped, entries))
1060        / sizeof (struct bfd_mmapped_entry));
1061   mmapped->next_entry = 1;
1062   abfd->mmapped = mmapped;
1063   *entry = mmapped->entries;
1064   return mmapped;
1065 }
1066
1067 /* Mmap a memory region of RSIZE bytes with PROT at the current offset.
1068    Return mmap address and size in MAP_ADDR and MAP_SIZE.  Return NULL
1069    on invalid input and MAP_FAILED for mmap failure.  */
1070
1071 static void *
1072 bfd_mmap_local (bfd *abfd, size_t rsize, int prot, void **map_addr,
1073                 size_t *map_size)
1074 {
1075   /* We mmap on the underlying file.  In an archive it might be nice
1076      to limit RSIZE to the element size, but that can be fuzzed and
1077      the offset returned by bfd_tell is relative to the start of the
1078      element.  Therefore to reliably stop access beyond the end of a
1079      file (and resulting bus errors) we must work with the underlying
1080      file offset and size, and trust that callers will limit access to
1081      within an archive element.  */
1082   while (abfd->my_archive != NULL
1083          && !bfd_is_thin_archive (abfd->my_archive))
1084     abfd = abfd->my_archive;
1085
1086   ufile_ptr filesize = bfd_get_size (abfd);
1087   ufile_ptr offset = bfd_tell (abfd);
1088   if (filesize < offset || filesize - offset < rsize)
1089     {
1090       bfd_set_error (bfd_error_file_truncated);
1091       return NULL;
1092     }
1093
1094   void *mem;
1095   mem = bfd_mmap (abfd, NULL, rsize, prot, MAP_PRIVATE, offset,
1096                   map_addr, map_size);
1097   return mem;
1098 }
1099
1100 /* Mmap a readonly memory region of RSIZE bytes at the current offset.
1101    Return mmap address and size in MAP_ADDR and MAP_SIZE.  Return NULL
1102    on invalid input and MAP_FAILED for mmap failure.  */
1103
1104 void *
1105 _bfd_mmap_readonly_temporary (bfd *abfd, size_t rsize, void **map_addr,
1106                               size_t *map_size)
1107 {
1108   /* Use mmap only if section size >= the minimum mmap section size.  */
1109   if (rsize < _bfd_minimum_mmap_size)
1110     {
1111       void *mem = _bfd_malloc_and_read (abfd, rsize, rsize);
1112       /* NB: Set *MAP_ADDR to MEM and *MAP_SIZE to 0 to indicate that
1113          _bfd_malloc_and_read is called.  */
1114       *map_addr = mem;
1115       *map_size = 0;
1116       return mem;
1117     }
1118
1119   return bfd_mmap_local (abfd, rsize, PROT_READ, map_addr, map_size);
1120 }
1121
1122 /* Munmap RSIZE bytes at PTR.  */
1123
1124 void
1125 _bfd_munmap_readonly_temporary (void *ptr, size_t rsize)
1126 {
1127   /* NB: Since _bfd_munmap_readonly_temporary is called like free, PTR
1128      may be NULL.  Otherwise, PTR and RSIZE must be valid.  If RSIZE is
1129      0, _bfd_malloc_and_read is called.  */
1130   if (ptr == NULL)
1131     return;
1132   if (rsize != 0)
1133     {
1134       if (munmap (ptr, rsize) != 0)
1135         abort ();
1136     }
1137   else
1138     free (ptr);
1139 }
1140
1141 /* Mmap a readonly memory region of RSIZE bytes at the current offset.
1142    Return NULL on invalid input or mmap failure.  */
1143
1144 void *
1145 _bfd_mmap_readonly_persistent (bfd *abfd, size_t rsize)
1146 {
1147   /* Use mmap only if section size >= the minimum mmap section size.  */
1148   if (rsize < _bfd_minimum_mmap_size)
1149     return _bfd_alloc_and_read (abfd, rsize, rsize);
1150
1151   void *mem, *map_addr;
1152   size_t map_size;
1153   mem = bfd_mmap_local (abfd, rsize, PROT_READ, &map_addr, &map_size);
1154   if (mem == NULL)
1155     return mem;
1156   if (mem == MAP_FAILED)
1157     return _bfd_alloc_and_read (abfd, rsize, rsize);
1158
1159   struct bfd_mmapped_entry *entry;
1160   unsigned int next_entry;
1161   struct bfd_mmapped *mmapped = abfd->mmapped;
1162   if (mmapped != NULL
1163       && (next_entry = mmapped->next_entry) < mmapped->max_entry)
1164     {
1165       entry = &mmapped->entries[next_entry];
1166       mmapped->next_entry++;
1167     }
1168   else
1169     {
1170       mmapped = bfd_allocate_mmapped_page (abfd, &entry);
1171       if (mmapped == NULL)
1172         {
1173           munmap (map_addr, map_size);
1174           return NULL;
1175         }
1176     }
1177
1178   entry->addr = map_addr;
1179   entry->size = map_size;
1180
1181   return mem;
1182 }
1183 #endif
1184
1185 /* Attempt to read *SIZE_P bytes from ABFD's iostream to *DATA_P.
1186    Return true if the full the amount has been read.  If *DATA_P is
1187    NULL, mmap should be used, return the memory address at the
1188    current offset in *DATA_P as well as return mmap address and size
1189    in *MMAP_BASE and *SIZE_P.  Otherwise, return NULL in *MMAP_BASE
1190    and 0 in *SIZE_P.  If FINAL_LINK is true, this is called from
1191    elf_link_read_relocs_from_section.  */
1192
1193 bool
1194 _bfd_mmap_read_temporary (void **data_p, size_t *size_p,
1195                           void **mmap_base, bfd *abfd,
1196                           bool final_link ATTRIBUTE_UNUSED)
1197 {
1198   void *data = *data_p;
1199   size_t size = *size_p;
1200
1201 #ifdef USE_MMAP
1202   /* NB: When FINAL_LINK is true, the size of the preallocated buffer
1203      is _bfd_minimum_mmap_size and use mmap if the data size >=
1204      _bfd_minimum_mmap_size.  Otherwise, use mmap if ABFD isn't an IR
1205      input or the data size >= _bfd_minimum_mmap_size.  */
1206   bool use_mmmap;
1207   bool mmap_size = size >= _bfd_minimum_mmap_size;
1208   if (final_link)
1209     use_mmmap = mmap_size;
1210   else
1211     use_mmmap = (mmap_size
1212                  && data == NULL
1213                  && (abfd->flags & BFD_PLUGIN) == 0);
1214   if (use_mmmap)
1215     {
1216       void *mmaped = _bfd_mmap_readonly_temporary (abfd, size,
1217                                                    mmap_base,
1218                                                    size_p);
1219       /* MAP_FAILED is returned when called from GDB on an object with
1220          opncls_iovec.  Use bfd_read in this case.  */
1221       if (mmaped != MAP_FAILED)
1222         {
1223           if (mmaped == NULL)
1224             abort ();
1225           *data_p = mmaped;
1226           return true;
1227         }
1228     }
1229 #endif
1230
1231   if (data == NULL)
1232     {
1233       data = bfd_malloc (size);
1234       if (data == NULL)
1235         return false;
1236       *data_p = data;
1237       /* NB: _bfd_munmap_readonly_temporary will free *MMAP_BASE if
1238          *SIZE_P == 0.  */
1239       *mmap_base = data;
1240     }
1241   else
1242     *mmap_base = NULL;
1243   *size_p = 0;
1244   return bfd_read (data, size, abfd) == size;
1245 }
1246
1247 /* Default implementation */
1248
1249 bool
1250 _bfd_generic_get_section_contents (bfd *abfd,
1251                                    sec_ptr section,
1252                                    void *location,
1253                                    file_ptr offset,
1254                                    bfd_size_type count)
1255 {
1256   bfd_size_type sz;
1257   if (count == 0)
1258     return true;
1259
1260   if (section->compress_status != COMPRESS_SECTION_NONE)
1261     {
1262       _bfd_error_handler
1263         /* xgettext:c-format */
1264         (_("%pB: unable to get decompressed section %pA"),
1265          abfd, section);
1266       bfd_set_error (bfd_error_invalid_operation);
1267       return false;
1268     }
1269
1270 #ifdef USE_MMAP
1271   if (section->mmapped_p
1272       && (section->contents != NULL || location != NULL))
1273     {
1274       _bfd_error_handler
1275         /* xgettext:c-format */
1276         (_("%pB: mapped section %pA has non-NULL buffer"),
1277          abfd, section);
1278       bfd_set_error (bfd_error_invalid_operation);
1279       return false;
1280     }
1281 #endif
1282
1283   sz = bfd_get_section_limit_octets (abfd, section);
1284   if (offset + count < count
1285       || offset + count > sz
1286       || (abfd->my_archive != NULL
1287           && !bfd_is_thin_archive (abfd->my_archive)
1288           && ((ufile_ptr) section->filepos + offset + count
1289               > arelt_size (abfd))))
1290     {
1291       bfd_set_error (bfd_error_invalid_operation);
1292       return false;
1293     }
1294
1295   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
1296     return false;
1297
1298 #ifdef USE_MMAP
1299   if (section->mmapped_p)
1300     {
1301       if (location != 0
1302           || bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1303         abort ();
1304
1305       int prot = ((section->reloc_count == 0)
1306                   ? PROT_READ : PROT_READ | PROT_WRITE);
1307
1308       location = bfd_mmap_local
1309         (abfd, count, prot, &elf_section_data (section)->contents_addr,
1310          &elf_section_data (section)->contents_size);
1311
1312       if (location == NULL)
1313         return false;
1314
1315       /* Check for iovec not supporting mmap.  */
1316       if (location != MAP_FAILED)
1317         {
1318           section->contents = location;
1319           return true;
1320         }
1321
1322       /* Malloc the buffer and call bfd_read.  */
1323       location = (bfd_byte *) bfd_malloc (count);
1324       if (location == NULL)
1325         {
1326           if (bfd_get_error () == bfd_error_no_memory)
1327             _bfd_error_handler
1328               /* xgettext:c-format */
1329               (_("error: %pB(%pA) is too large (%#" PRIx64 " bytes)"),
1330                abfd, section, (uint64_t) count);
1331           return false;
1332         }
1333       section->contents = location;
1334     }
1335 #endif
1336
1337   if (bfd_read (location, count, abfd) != count)
1338     return false;
1339
1340   return true;
1341 }
1342
1343 /* This generic function can only be used in implementations where creating
1344    NEW sections is disallowed.  It is useful in patching existing sections
1345    in read-write files, though.  See other set_section_contents functions
1346    to see why it doesn't work for new sections.  */
1347 bool
1348 _bfd_generic_set_section_contents (bfd *abfd,
1349                                    sec_ptr section,
1350                                    const void *location,
1351                                    file_ptr offset,
1352                                    bfd_size_type count)
1353 {
1354   if (count == 0)
1355     return true;
1356
1357   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1358       || bfd_write (location, count, abfd) != count)
1359     return false;
1360
1361   return true;
1362 }
1363
1364 /*
1365 INTERNAL_FUNCTION
1366         bfd_log2
1367
1368 SYNOPSIS
1369         unsigned int bfd_log2 (bfd_vma x);
1370
1371 DESCRIPTION
1372         Return the log base 2 of the value supplied, rounded up.  E.g., an
1373         @var{x} of 1025 returns 11.  A @var{x} of 0 returns 0.
1374 */
1375
1376 unsigned int
1377 bfd_log2 (bfd_vma x)
1378 {
1379   unsigned int result = 0;
1380
1381   if (x <= 1)
1382     return result;
1383   --x;
1384   do
1385     ++result;
1386   while ((x >>= 1) != 0);
1387   return result;
1388 }
1389
1390 bool
1391 bfd_generic_is_local_label_name (bfd *abfd, const char *name)
1392 {
1393   char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
1394
1395   return name[0] == locals_prefix;
1396 }
1397
1398 /* Helper function for reading uleb128 encoded data.  */
1399
1400 bfd_vma
1401 _bfd_read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1402                            bfd_byte *buf,
1403                            unsigned int *bytes_read_ptr)
1404 {
1405   bfd_vma result;
1406   unsigned int num_read;
1407   unsigned int shift;
1408   bfd_byte byte;
1409
1410   result = 0;
1411   shift = 0;
1412   num_read = 0;
1413   do
1414     {
1415       byte = bfd_get_8 (abfd, buf);
1416       buf++;
1417       num_read++;
1418       if (shift < 8 * sizeof (result))
1419         {
1420           result |= (((bfd_vma) byte & 0x7f) << shift);
1421           shift += 7;
1422         }
1423     }
1424   while (byte & 0x80);
1425   *bytes_read_ptr = num_read;
1426   return result;
1427 }
1428
1429 /* Read in a LEB128 encoded value from ABFD starting at *PTR.
1430    If SIGN is true, return a signed LEB128 value.
1431    *PTR is incremented by the number of bytes read.
1432    No bytes will be read at address END or beyond.  */
1433
1434 bfd_vma
1435 _bfd_safe_read_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1436                        bfd_byte **ptr,
1437                        bool sign,
1438                        const bfd_byte * const end)
1439 {
1440   bfd_vma result = 0;
1441   unsigned int shift = 0;
1442   bfd_byte byte = 0;
1443   bfd_byte *data = *ptr;
1444
1445   while (data < end)
1446     {
1447       byte = bfd_get_8 (abfd, data);
1448       data++;
1449       if (shift < 8 * sizeof (result))
1450         {
1451           result |= ((bfd_vma) (byte & 0x7f)) << shift;
1452           shift += 7;
1453         }
1454       if ((byte & 0x80) == 0)
1455         break;
1456     }
1457
1458   *ptr = data;
1459
1460   if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
1461     result |= -((bfd_vma) 1 << shift);
1462
1463   return result;
1464 }
1465
1466 /* Helper function for reading sleb128 encoded data.  */
1467
1468 bfd_signed_vma
1469 _bfd_read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1470                          bfd_byte *buf,
1471                          unsigned int *bytes_read_ptr)
1472 {
1473   bfd_vma result;
1474   unsigned int shift;
1475   unsigned int num_read;
1476   bfd_byte byte;
1477
1478   result = 0;
1479   shift = 0;
1480   num_read = 0;
1481   do
1482     {
1483       byte = bfd_get_8 (abfd, buf);
1484       buf ++;
1485       num_read ++;
1486       if (shift < 8 * sizeof (result))
1487         {
1488           result |= (((bfd_vma) byte & 0x7f) << shift);
1489           shift += 7;
1490         }
1491     }
1492   while (byte & 0x80);
1493   if (shift < 8 * sizeof (result) && (byte & 0x40))
1494     result |= (((bfd_vma) -1) << shift);
1495   *bytes_read_ptr = num_read;
1496   return result;
1497 }
1498
1499 /* Write VAL in uleb128 format to P.
1500    END indicates the last byte of allocated space for the uleb128 value to fit
1501    in.
1502    Return a pointer to the byte following the last byte that was written, or
1503    NULL if the uleb128 value does not fit in the allocated space between P and
1504    END.  */
1505 bfd_byte *
1506 _bfd_write_unsigned_leb128 (bfd_byte *p, bfd_byte *end, bfd_vma val)
1507 {
1508   bfd_byte c;
1509   do
1510     {
1511       if (p > end)
1512         return NULL;
1513       c = val & 0x7f;
1514       val >>= 7;
1515       if (val)
1516         c |= 0x80;
1517       *(p++) = c;
1518     }
1519   while (val);
1520   return p;
1521 }
1522
1523 bool
1524 _bfd_generic_init_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
1525                                         asection *isec ATTRIBUTE_UNUSED,
1526                                         bfd *obfd ATTRIBUTE_UNUSED,
1527                                         asection *osec ATTRIBUTE_UNUSED,
1528                                         struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
1529 {
1530   return true;
1531 }
1532
1533 #ifdef HAVE_MMAP
1534 uintptr_t _bfd_pagesize;
1535 uintptr_t _bfd_pagesize_m1;
1536 uintptr_t _bfd_minimum_mmap_size;
1537
1538 __attribute__ ((unused, constructor))
1539 static void
1540 bfd_init_pagesize (void)
1541 {
1542   _bfd_pagesize = getpagesize ();
1543   if (_bfd_pagesize == 0)
1544     abort ();
1545   _bfd_pagesize_m1 = _bfd_pagesize - 1;
1546   /* The minimum section size to use mmap.  */
1547   _bfd_minimum_mmap_size = _bfd_pagesize * 4;
1548 }
1549 #endif