bfd/libbfd.c

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