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