bfd/libbfd.c

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