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   /* We do allow reading of a section after bfd_final_link has
 870      written the contents out to disk.  In that situation, rawsize is
 871      just a stale version of size, so ignore it.  Otherwise we must be
 872      reading an input section, where rawsize, if different to size,
 873      is the on-disk size.  */
 874   if (abfd->direction != write_direction && section->rawsize != 0)
 875     sz = section->rawsize;
 876   else
 877     sz = section->size;
 878   if (offset + count < count
 879       || offset + count > sz)
 880     {
 881       bfd_set_error (bfd_error_invalid_operation);
 882       return FALSE;
 883     }
 884
 885   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
 886       || bfd_bread (location, count, abfd) != count)
 887     return FALSE;
 888
 889   return TRUE;
 890 }
 891
 892 bfd_boolean
 893 _bfd_generic_get_section_contents_in_window
 894   (bfd *abfd ATTRIBUTE_UNUSED,
 895    sec_ptr section ATTRIBUTE_UNUSED,
 896    bfd_window *w ATTRIBUTE_UNUSED,
 897    file_ptr offset ATTRIBUTE_UNUSED,
 898    bfd_size_type count ATTRIBUTE_UNUSED)
 899 {
 900 #ifdef USE_MMAP
 901   bfd_size_type sz;
 902
 903   if (count == 0)
 904     return TRUE;
 905   if (abfd->xvec->_bfd_get_section_contents
 906       != _bfd_generic_get_section_contents)
 907     {
 908       /* We don't know what changes the bfd's get_section_contents
 909          method may have to make.  So punt trying to map the file
 910          window, and let get_section_contents do its thing.  */
 911       /* @@ FIXME : If the internal window has a refcount of 1 and was
 912          allocated with malloc instead of mmap, just reuse it.  */
 913       bfd_free_window (w);
 914       w->i = bfd_zmalloc (sizeof (bfd_window_internal));
 915       if (w->i == NULL)
 916         return FALSE;
 917       w->i->data = bfd_malloc (count);
 918       if (w->i->data == NULL)
 919         {
 920           free (w->i);
 921           w->i = NULL;
 922           return FALSE;
 923         }
 924       w->i->mapped = 0;
 925       w->i->refcount = 1;
 926       w->size = w->i->size = count;
 927       w->data = w->i->data;
 928       return bfd_get_section_contents (abfd, section, w->data, offset, count);
 929     }
 930   if (abfd->direction != write_direction && section->rawsize != 0)
 931     sz = section->rawsize;
 932   else
 933     sz = section->size;
 934   if (offset + count > sz
 935       || ! bfd_get_file_window (abfd, section->filepos + offset, count, w,
 936                                 TRUE))
 937     return FALSE;
 938   return TRUE;
 939 #else
 940   abort ();
 941 #endif
 942 }
 943
 944 /* This generic function can only be used in implementations where creating
 945    NEW sections is disallowed.  It is useful in patching existing sections
 946    in read-write files, though.  See other set_section_contents functions
 947    to see why it doesn't work for new sections.  */
 948 bfd_boolean
 949 _bfd_generic_set_section_contents (bfd *abfd,
 950                                    sec_ptr section,
 951                                    const void *location,
 952                                    file_ptr offset,
 953                                    bfd_size_type count)
 954 {
 955   if (count == 0)
 956     return TRUE;
 957
 958   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
 959       || bfd_bwrite (location, count, abfd) != count)
 960     return FALSE;
 961
 962   return TRUE;
 963 }
 964
 965 /*
 966 INTERNAL_FUNCTION
 967         bfd_log2
 968
 969 SYNOPSIS
 970         unsigned int bfd_log2 (bfd_vma x);
 971
 972 DESCRIPTION
 973         Return the log base 2 of the value supplied, rounded up.  E.g., an
 974         @var{x} of 1025 returns 11.  A @var{x} of 0 returns 0.
 975 */
 976
 977 unsigned int
 978 bfd_log2 (bfd_vma x)
 979 {
 980   unsigned int result = 0;
 981
 982   if (x <= 1)
 983     return result;
 984   --x;
 985   do
 986     ++result;
 987   while ((x >>= 1) != 0);
 988   return result;
 989 }
 990
 991 bfd_boolean
 992 bfd_generic_is_local_label_name (bfd *abfd, const char *name)
 993 {
 994   char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
 995
 996   return name[0] == locals_prefix;
 997 }
 998
 999 /*  Can be used from / for bfd_merge_private_bfd_data to check that
1000     endianness matches between input and output file.  Returns
1001     TRUE for a match, otherwise returns FALSE and emits an error.  */
1002 bfd_boolean
1003 _bfd_generic_verify_endian_match (bfd *ibfd, bfd *obfd)
1004 {
1005   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1006       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1007       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1008     {
1009       const char *msg;
1010
1011       if (bfd_big_endian (ibfd))
1012         msg = _("%B: compiled for a big endian system and target is little endian");
1013       else
1014         msg = _("%B: compiled for a little endian system and target is big endian");
1015
1016       (*_bfd_error_handler) (msg, ibfd);
1017
1018       bfd_set_error (bfd_error_wrong_format);
1019       return FALSE;
1020     }
1021
1022   return TRUE;
1023 }
1024
1025 /* Give a warning at runtime if someone compiles code which calls
1026    old routines.  */
1027
1028 void
1029 warn_deprecated (const char *what,
1030                  const char *file,
1031                  int line,
1032                  const char *func)
1033 {
1034   /* Poor man's tracking of functions we've already warned about.  */
1035   static size_t mask = 0;
1036
1037   if (~(size_t) func & ~mask)
1038     {
1039       fflush (stdout);
1040       /* Note: separate sentences in order to allow
1041          for translation into other languages.  */
1042       if (func)
1043         fprintf (stderr, _("Deprecated %s called at %s line %d in %s\n"),
1044                  what, file, line, func);
1045       else
1046         fprintf (stderr, _("Deprecated %s called\n"), what);
1047       fflush (stderr);
1048       mask |= ~(size_t) func;
1049     }
1050 }
1051
1052 /* Helper function for reading uleb128 encoded data.  */
1053
1054 bfd_vma
1055 read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1056                       bfd_byte *buf,
1057                       unsigned int *bytes_read_ptr)
1058 {
1059   bfd_vma result;
1060   unsigned int num_read;
1061   unsigned int shift;
1062   unsigned char byte;
1063
1064   result = 0;
1065   shift = 0;
1066   num_read = 0;
1067   do
1068     {
1069       byte = bfd_get_8 (abfd, buf);
1070       buf++;
1071       num_read++;
1072       result |= (((bfd_vma) byte & 0x7f) << shift);
1073       shift += 7;
1074     }
1075   while (byte & 0x80);
1076   *bytes_read_ptr = num_read;
1077   return result;
1078 }
1079
1080 /* Helper function for reading sleb128 encoded data.  */
1081
1082 bfd_signed_vma
1083 read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1084                     bfd_byte *buf,
1085                     unsigned int *bytes_read_ptr)
1086 {
1087   bfd_vma result;
1088   unsigned int shift;
1089   unsigned int num_read;
1090   unsigned char byte;
1091
1092   result = 0;
1093   shift = 0;
1094   num_read = 0;
1095   do
1096     {
1097       byte = bfd_get_8 (abfd, buf);
1098       buf ++;
1099       num_read ++;
1100       result |= (((bfd_vma) byte & 0x7f) << shift);
1101       shift += 7;
1102     }
1103   while (byte & 0x80);
1104   if (shift < 8 * sizeof (result) && (byte & 0x40))
1105     result |= (((bfd_vma) -1) << shift);
1106   *bytes_read_ptr = num_read;
1107   return result;
1108 }
1109
1110 bfd_boolean
1111 _bfd_generic_find_line (bfd *abfd ATTRIBUTE_UNUSED,
1112                        asymbol **symbols ATTRIBUTE_UNUSED,
1113                        asymbol *symbol ATTRIBUTE_UNUSED,
1114                        const char **filename_ptr ATTRIBUTE_UNUSED,
1115                        unsigned int *linenumber_ptr ATTRIBUTE_UNUSED)
1116 {
1117   return FALSE;
1118 }
1119
1120 bfd_boolean
1121 _bfd_generic_init_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
1122                                         asection *isec ATTRIBUTE_UNUSED,
1123                                         bfd *obfd ATTRIBUTE_UNUSED,
1124                                         asection *osec ATTRIBUTE_UNUSED,
1125                                         struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
1126 {
1127   return TRUE;
1128 }