sdcc/support/sdbinutils/bfd/libbfd.c

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