contrib/binutils-2.25/bfd/libbfd.c

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