bfd/libbfd.c

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