bfd/libbfd.c

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