bfd/libbfd.c

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