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