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