bfd/libbfd.c

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