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