bfd/libbfd.c

   1 /* Assorted BFD support routines, only used internally.
   2    Copyright 1990, 91, 92, 93, 94 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24
  25 static int real_read PARAMS ((PTR, size_t, size_t, FILE *));
  26
  27 /*
  28 SECTION
  29         Internal functions
  30
  31 DESCRIPTION
  32         These routines are used within BFD.
  33         They are not intended for export, but are documented here for
  34         completeness.
  35 */
  36
  37 /* A routine which is used in target vectors for unsupported
  38    operations.  */
  39
  40 /*ARGSUSED*/
  41 boolean
  42 bfd_false (ignore)
  43      bfd *ignore;
  44 {
  45   bfd_set_error (bfd_error_invalid_operation);
  46   return false;
  47 }
  48
  49 /* A routine which is used in target vectors for supported operations
  50    which do not actually do anything.  */
  51
  52 /*ARGSUSED*/
  53 boolean
  54 bfd_true (ignore)
  55      bfd *ignore;
  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 /*ARGSUSED*/
  64 PTR
  65 bfd_nullvoidptr (ignore)
  66      bfd *ignore;
  67 {
  68   bfd_set_error (bfd_error_invalid_operation);
  69   return NULL;
  70 }
  71
  72 /*ARGSUSED*/
  73 int
  74 bfd_0 (ignore)
  75      bfd *ignore;
  76 {
  77   return 0;
  78 }
  79
  80 /*ARGSUSED*/
  81 unsigned int
  82 bfd_0u (ignore)
  83      bfd *ignore;
  84 {
  85    return 0;
  86 }
  87
  88 /*ARGUSED*/
  89 long
  90 bfd_0l (ignore)
  91      bfd *ignore;
  92 {
  93   return 0;
  94 }
  95
  96 /* A routine which is used in target vectors for unsupported
  97    operations which return -1 on error.  */
  98
  99 /*ARGSUSED*/
 100 long
 101 _bfd_n1 (ignore_abfd)
 102      bfd *ignore_abfd;
 103 {
 104   bfd_set_error (bfd_error_invalid_operation);
 105   return -1;
 106 }
 107
 108 /*ARGSUSED*/
 109 void
 110 bfd_void (ignore)
 111      bfd *ignore;
 112 {
 113 }
 114
 115 /*ARGSUSED*/
 116 boolean
 117 _bfd_nocore_core_file_matches_executable_p (ignore_core_bfd, ignore_exec_bfd)
 118      bfd *ignore_core_bfd;
 119      bfd *ignore_exec_bfd;
 120 {
 121   bfd_set_error (bfd_error_invalid_operation);
 122   return false;
 123 }
 124
 125 /* Routine to handle core_file_failing_command entry point for targets
 126    without core file support.  */
 127
 128 /*ARGSUSED*/
 129 char *
 130 _bfd_nocore_core_file_failing_command (ignore_abfd)
 131      bfd *ignore_abfd;
 132 {
 133   bfd_set_error (bfd_error_invalid_operation);
 134   return (char *)NULL;
 135 }
 136
 137 /* Routine to handle core_file_failing_signal entry point for targets
 138    without core file support.  */
 139
 140 /*ARGSUSED*/
 141 int
 142 _bfd_nocore_core_file_failing_signal (ignore_abfd)
 143      bfd *ignore_abfd;
 144 {
 145   bfd_set_error (bfd_error_invalid_operation);
 146   return 0;
 147 }
 148
 149 /*ARGSUSED*/
 150 const bfd_target *
 151 _bfd_dummy_target (ignore_abfd)
 152      bfd *ignore_abfd;
 153 {
 154   bfd_set_error (bfd_error_wrong_format);
 155   return 0;
 156 }
 157 \f
 158
 159 #ifndef bfd_zmalloc
 160 /* allocate and clear storage */
 161
 162 char *
 163 bfd_zmalloc (size)
 164      bfd_size_type size;
 165 {
 166   char *ptr = (char *) malloc ((size_t) size);
 167
 168   if (ptr && size)
 169    memset(ptr, 0, (size_t) size);
 170
 171   return ptr;
 172 }
 173 #endif /* bfd_zmalloc */
 174 \f
 175 /* Some IO code */
 176
 177
 178 /* Note that archive entries don't have streams; they share their parent's.
 179    This allows someone to play with the iostream behind BFD's back.
 180
 181    Also, note that the origin pointer points to the beginning of a file's
 182    contents (0 for non-archive elements).  For archive entries this is the
 183    first octet in the file, NOT the beginning of the archive header. */
 184
 185 static int
 186 real_read (where, a,b, file)
 187      PTR where;
 188      size_t a;
 189      size_t b;
 190      FILE *file;
 191 {
 192   return fread (where, a, b, file);
 193 }
 194
 195 /* Return value is amount read (FIXME: how are errors and end of file dealt
 196    with?  We never call bfd_set_error, which is probably a mistake).  */
 197
 198 bfd_size_type
 199 bfd_read (ptr, size, nitems, abfd)
 200      PTR ptr;
 201      bfd_size_type size;
 202      bfd_size_type nitems;
 203      bfd *abfd;
 204 {
 205   int nread;
 206   nread = real_read (ptr, 1, (size_t)(size*nitems), bfd_cache_lookup(abfd));
 207 #ifdef FILE_OFFSET_IS_CHAR_INDEX
 208   if (nread > 0)
 209     abfd->where += nread;
 210 #endif
 211
 212   /* Set bfd_error if we did not read as much data as we expected.
 213
 214      If the read failed due to an error set the bfd_error_system_call,
 215      else set bfd_error_file_truncated.
 216
 217      A BFD backend may wish to override bfd_error_file_truncated to
 218      provide something more useful (eg. no_symbols or wrong_format).  */
 219   if (nread < (int)(size * nitems))
 220     {
 221       if (ferror (bfd_cache_lookup (abfd)))
 222         bfd_set_error (bfd_error_system_call);
 223       else
 224         bfd_set_error (bfd_error_file_truncated);
 225     }
 226
 227   return nread;
 228 }
 229
 230 /* The window support stuff should probably be broken out into
 231    another file....  */
 232 /* The idea behind the next and refcount fields is that one mapped
 233    region can suffice for multiple read-only windows or multiple
 234    non-overlapping read-write windows.  It's not implemented yet
 235    though.  */
 236 struct _bfd_window_internal {
 237   struct _bfd_window_internal *next;
 238   PTR data;
 239   bfd_size_type size;
 240   int refcount : 31;            /* should be enough... */
 241   unsigned mapped : 1;          /* 1 = mmap, 0 = malloc */
 242 };
 243
 244 void
 245 bfd_init_window (windowp)
 246      bfd_window *windowp;
 247 {
 248   windowp->data = 0;
 249   windowp->i = 0;
 250   windowp->size = 0;
 251 }
 252
 253 #undef HAVE_MPROTECT /* code's not tested yet */
 254
 255 #if HAVE_MMAP || HAVE_MPROTECT
 256 #include <sys/types.h>
 257 #include <sys/mman.h>
 258 #endif
 259
 260 #ifndef MAP_FILE
 261 #define MAP_FILE 0
 262 #endif
 263
 264 static int debug_windows;
 265
 266 void
 267 bfd_free_window (windowp)
 268      bfd_window *windowp;
 269 {
 270   bfd_window_internal *i = windowp->i;
 271   windowp->i = 0;
 272   windowp->data = 0;
 273   if (i == 0)
 274     return;
 275   i->refcount--;
 276   if (debug_windows)
 277     fprintf (stderr, "freeing window @%p<%p,%lx,%p>\n",
 278              windowp, windowp->data, windowp->size, windowp->i);
 279   if (i->refcount != 0)
 280     return;
 281
 282   if (i->mapped)
 283     {
 284 #ifdef HAVE_MMAP
 285       munmap (i->data, i->size);
 286       goto no_free;
 287 #else
 288       abort ();
 289 #endif
 290     }
 291 #ifdef HAVE_MPROTECT
 292   mprotect (i->data, i->size, PROT_READ | PROT_WRITE);
 293 #endif
 294   free (i->data);
 295 #ifdef HAVE_MMAP
 296  no_free:
 297 #endif
 298   i->data = 0;
 299   /* There should be no more references to i at this point.  */
 300   free (i);
 301 }
 302
 303 static int ok_to_map = 1;
 304
 305 boolean
 306 bfd_get_file_window (abfd, offset, size, windowp, writable)
 307      bfd *abfd;
 308      file_ptr offset;
 309      bfd_size_type size;
 310      bfd_window *windowp;
 311      int writable;
 312 {
 313   static size_t pagesize;
 314   bfd_window_internal *i = windowp->i;
 315   size_t size_to_alloc = size;
 316
 317   if (debug_windows)
 318     fprintf (stderr, "bfd_get_file_window (%p, %6ld, %6ld, %p<%p,%lx,%p>, %d)",
 319              abfd, (long) offset, (long) size,
 320              windowp, windowp->data, windowp->size, windowp->i,
 321              writable);
 322
 323   /* Make sure we know the page size, so we can be friendly to mmap.  */
 324   if (pagesize == 0)
 325     pagesize = getpagesize ();
 326   if (pagesize == 0)
 327     abort ();
 328
 329   if (i == 0)
 330     {
 331       windowp->i = i = (bfd_window_internal *) bfd_zmalloc (sizeof (bfd_window_internal));
 332       if (i == 0)
 333         return false;
 334       i->data = 0;
 335     }
 336 #ifdef HAVE_MMAP
 337   if (ok_to_map && (i->data == 0 || i->mapped == 1))
 338     {
 339       file_ptr file_offset, offset2;
 340       size_t real_size;
 341       int fd;
 342       FILE *f;
 343
 344       /* Find the real file and the real offset into it.  */
 345       while (abfd->my_archive != NULL)
 346         {
 347           offset += abfd->origin;
 348           abfd = abfd->my_archive;
 349         }
 350       f = bfd_cache_lookup (abfd);
 351       fd = fileno (f);
 352
 353       /* Compute offsets and size for mmap and for the user's data.  */
 354       offset2 = offset % pagesize;
 355       if (offset2 < 0)
 356         abort ();
 357       file_offset = offset - offset2;
 358       real_size = offset + size - file_offset;
 359       real_size = real_size + pagesize - 1;
 360       real_size -= real_size % pagesize;
 361
 362       /* If we're re-using a memory region, make sure it's big enough.  */
 363       if (i->data && i->size < size)
 364         {
 365           munmap (i->data, i->size);
 366           i->data = 0;
 367         }
 368       i->data = mmap (i->data, real_size,
 369                       writable ? PROT_WRITE | PROT_READ : PROT_READ,
 370                       writable ? MAP_FILE | MAP_PRIVATE : MAP_FILE,
 371                       fd, file_offset);
 372       if (i->data == (PTR) -1)
 373         {
 374           /* An error happened.  Report it, or try using malloc, or
 375              something.  */
 376           bfd_set_error (bfd_error_system_call);
 377           i->data = 0;
 378           windowp->data = 0;
 379           if (debug_windows)
 380             fprintf (stderr, "\t\tmmap failed!\n");
 381           return false;
 382         }
 383       if (debug_windows)
 384         fprintf (stderr, "\n\tmapped %ld at %p, offset is %ld\n",
 385                  (long) real_size, i->data, (long) offset2);
 386       i->size = real_size;
 387       windowp->data = i->data + offset2;
 388       windowp->size = size;
 389       i->mapped = 1;
 390       return true;
 391     }
 392   else if (debug_windows)
 393     {
 394       if (ok_to_map)
 395         fprintf (stderr, "not mapping: data=%x mapped=%d\n",
 396                  i->data, i->mapped);
 397       else
 398         fprintf (stderr, "not mapping: env var not set\n");
 399     }
 400 #else
 401   ok_to_map = 0;
 402 #endif
 403
 404 #ifdef HAVE_MPROTECT
 405   if (!writable)
 406     {
 407       size_to_alloc += pagesize - 1;
 408       size_to_alloc -= size_to_alloc % pagesize;
 409     }
 410 #endif
 411   if (debug_windows)
 412     fprintf (stderr, "\n\t%s(%6ld)",
 413              i->data ? "realloc" : " malloc", (long) size_to_alloc);
 414   if (i->data)
 415     i->data = (PTR) realloc (i->data, size_to_alloc);
 416   else
 417     i->data = (PTR) malloc (size_to_alloc);
 418   if (debug_windows)
 419     fprintf (stderr, "\t-> %p\n", i->data);
 420   i->refcount = 1;
 421   if (i->data == NULL)
 422     {
 423       if (size_to_alloc == 0)
 424         return true;
 425       bfd_set_error (bfd_error_no_memory);
 426       return false;
 427     }
 428   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
 429     return false;
 430   i->size = bfd_read (i->data, size, 1, abfd);
 431   if (i->size != size)
 432     return false;
 433   i->mapped = 0;
 434 #ifdef HAVE_MPROTECT
 435   if (!writable)
 436     {
 437       if (debug_windows)
 438         fprintf (stderr, "\tmprotect (%p, %ld, PROT_READ)\n", i->data,
 439                  (long) i->size);
 440       mprotect (i->data, i->size, PROT_READ);
 441     }
 442 #endif
 443   windowp->data = i->data;
 444   windowp->size = i->size;
 445   return true;
 446 }
 447
 448 bfd_size_type
 449 bfd_write (ptr, size, nitems, abfd)
 450      CONST PTR ptr;
 451      bfd_size_type size;
 452      bfd_size_type nitems;
 453      bfd *abfd;
 454 {
 455   long nwrote = fwrite (ptr, 1, (size_t) (size * nitems),
 456                         bfd_cache_lookup (abfd));
 457 #ifdef FILE_OFFSET_IS_CHAR_INDEX
 458   if (nwrote > 0)
 459     abfd->where += nwrote;
 460 #endif
 461   if ((bfd_size_type) nwrote != size * nitems)
 462     {
 463 #ifdef ENOSPC
 464       if (nwrote >= 0)
 465         errno = ENOSPC;
 466 #endif
 467       bfd_set_error (bfd_error_system_call);
 468     }
 469   return nwrote;
 470 }
 471
 472 /*
 473 INTERNAL_FUNCTION
 474         bfd_write_bigendian_4byte_int
 475
 476 SYNOPSIS
 477         void bfd_write_bigendian_4byte_int(bfd *abfd,  int i);
 478
 479 DESCRIPTION
 480         Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
 481         endian order regardless of what else is going on.  This is useful in
 482         archives.
 483
 484 */
 485 void
 486 bfd_write_bigendian_4byte_int (abfd, i)
 487      bfd *abfd;
 488      int i;
 489 {
 490   bfd_byte buffer[4];
 491   bfd_putb32(i, buffer);
 492   if (bfd_write((PTR)buffer, 4, 1, abfd) != 4)
 493     abort ();
 494 }
 495
 496 long
 497 bfd_tell (abfd)
 498      bfd *abfd;
 499 {
 500   file_ptr ptr;
 501
 502   ptr = ftell (bfd_cache_lookup(abfd));
 503
 504   if (abfd->my_archive)
 505     ptr -= abfd->origin;
 506   abfd->where = ptr;
 507   return ptr;
 508 }
 509
 510 int
 511 bfd_flush (abfd)
 512      bfd *abfd;
 513 {
 514   return fflush (bfd_cache_lookup(abfd));
 515 }
 516
 517 /* Returns 0 for success, negative value for failure (in which case
 518    bfd_get_error can retrieve the error code).  */
 519 int
 520 bfd_stat (abfd, statbuf)
 521      bfd *abfd;
 522      struct stat *statbuf;
 523 {
 524   FILE *f;
 525   int result;
 526   f = bfd_cache_lookup (abfd);
 527   if (f == NULL)
 528     {
 529       bfd_set_error (bfd_error_system_call);
 530       return -1;
 531     }
 532   result = fstat (fileno (f), statbuf);
 533   if (result < 0)
 534     bfd_set_error (bfd_error_system_call);
 535   return result;
 536 }
 537
 538 /* Returns 0 for success, nonzero for failure (in which case bfd_get_error
 539    can retrieve the error code).  */
 540
 541 int
 542 bfd_seek (abfd, position, direction)
 543      bfd *abfd;
 544      file_ptr position;
 545      int direction;
 546 {
 547   int result;
 548   FILE *f;
 549   file_ptr file_position;
 550   /* For the time being, a BFD may not seek to it's end.  The problem
 551      is that we don't easily have a way to recognize the end of an
 552      element in an archive. */
 553
 554   BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);
 555
 556   if (direction == SEEK_CUR && position == 0)
 557     return 0;
 558 #ifdef FILE_OFFSET_IS_CHAR_INDEX
 559   if (abfd->format != bfd_archive && abfd->my_archive == 0)
 560     {
 561 #if 0
 562       /* Explanation for this code: I'm only about 95+% sure that the above
 563          conditions are sufficient and that all i/o calls are properly
 564          adjusting the `where' field.  So this is sort of an `assert'
 565          that the `where' field is correct.  If we can go a while without
 566          tripping the abort, we can probably safely disable this code,
 567          so that the real optimizations happen.  */
 568       file_ptr where_am_i_now;
 569       where_am_i_now = ftell (bfd_cache_lookup (abfd));
 570       if (abfd->my_archive)
 571         where_am_i_now -= abfd->origin;
 572       if (where_am_i_now != abfd->where)
 573         abort ();
 574 #endif
 575       if (direction == SEEK_SET && position == abfd->where)
 576         return 0;
 577     }
 578   else
 579     {
 580       /* We need something smarter to optimize access to archives.
 581          Currently, anything inside an archive is read via the file
 582          handle for the archive.  Which means that a bfd_seek on one
 583          component affects the `current position' in the archive, as
 584          well as in any other component.
 585
 586          It might be sufficient to put a spike through the cache
 587          abstraction, and look to the archive for the file position,
 588          but I think we should try for something cleaner.
 589
 590          In the meantime, no optimization for archives.  */
 591     }
 592 #endif
 593
 594   f = bfd_cache_lookup (abfd);
 595   file_position = position;
 596   if (direction == SEEK_SET && abfd->my_archive != NULL)
 597     file_position += abfd->origin;
 598
 599   result = fseek (f, file_position, direction);
 600
 601   if (result != 0)
 602     {
 603       /* Force redetermination of `where' field.  */
 604       bfd_tell (abfd);
 605       bfd_set_error (bfd_error_system_call);
 606     }
 607   else
 608     {
 609 #ifdef FILE_OFFSET_IS_CHAR_INDEX
 610       /* Adjust `where' field.  */
 611       if (direction == SEEK_SET)
 612         abfd->where = position;
 613       else
 614         abfd->where += position;
 615 #endif
 616     }
 617   return result;
 618 }
 619 \f
 620 /** The do-it-yourself (byte) sex-change kit */
 621
 622 /* The middle letter e.g. get<b>short indicates Big or Little endian
 623    target machine.  It doesn't matter what the byte order of the host
 624    machine is; these routines work for either.  */
 625
 626 /* FIXME: Should these take a count argument?
 627    Answer (gnu@cygnus.com):  No, but perhaps they should be inline
 628                              functions in swap.h #ifdef __GNUC__.
 629                              Gprof them later and find out.  */
 630
 631 /*
 632 FUNCTION
 633         bfd_put_size
 634 FUNCTION
 635         bfd_get_size
 636
 637 DESCRIPTION
 638         These macros as used for reading and writing raw data in
 639         sections; each access (except for bytes) is vectored through
 640         the target format of the BFD and mangled accordingly. The
 641         mangling performs any necessary endian translations and
 642         removes alignment restrictions.  Note that types accepted and
 643         returned by these macros are identical so they can be swapped
 644         around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
 645         to either <<bfd_get_32>> or <<bfd_get_64>>.
 646
 647         In the put routines, @var{val} must be a <<bfd_vma>>.  If we are on a
 648         system without prototypes, the caller is responsible for making
 649         sure that is true, with a cast if necessary.  We don't cast
 650         them in the macro definitions because that would prevent <<lint>>
 651         or <<gcc -Wall>> from detecting sins such as passing a pointer.
 652         To detect calling these with less than a <<bfd_vma>>, use
 653         <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
 654
 655 .
 656 .{* Byte swapping macros for user section data.  *}
 657 .
 658 .#define bfd_put_8(abfd, val, ptr) \
 659 .                (*((unsigned char *)(ptr)) = (unsigned char)(val))
 660 .#define bfd_put_signed_8 \
 661 .               bfd_put_8
 662 .#define bfd_get_8(abfd, ptr) \
 663 .                (*(unsigned char *)(ptr))
 664 .#define bfd_get_signed_8(abfd, ptr) \
 665 .               ((*(unsigned char *)(ptr) ^ 0x80) - 0x80)
 666 .
 667 .#define bfd_put_16(abfd, val, ptr) \
 668 .                BFD_SEND(abfd, bfd_putx16, ((val),(ptr)))
 669 .#define bfd_put_signed_16 \
 670 .                bfd_put_16
 671 .#define bfd_get_16(abfd, ptr) \
 672 .                BFD_SEND(abfd, bfd_getx16, (ptr))
 673 .#define bfd_get_signed_16(abfd, ptr) \
 674 .                BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
 675 .
 676 .#define bfd_put_32(abfd, val, ptr) \
 677 .                BFD_SEND(abfd, bfd_putx32, ((val),(ptr)))
 678 .#define bfd_put_signed_32 \
 679 .                bfd_put_32
 680 .#define bfd_get_32(abfd, ptr) \
 681 .                BFD_SEND(abfd, bfd_getx32, (ptr))
 682 .#define bfd_get_signed_32(abfd, ptr) \
 683 .                BFD_SEND(abfd, bfd_getx_signed_32, (ptr))
 684 .
 685 .#define bfd_put_64(abfd, val, ptr) \
 686 .                BFD_SEND(abfd, bfd_putx64, ((val), (ptr)))
 687 .#define bfd_put_signed_64 \
 688 .                bfd_put_64
 689 .#define bfd_get_64(abfd, ptr) \
 690 .                BFD_SEND(abfd, bfd_getx64, (ptr))
 691 .#define bfd_get_signed_64(abfd, ptr) \
 692 .                BFD_SEND(abfd, bfd_getx_signed_64, (ptr))
 693 .
 694 */
 695
 696 /*
 697 FUNCTION
 698         bfd_h_put_size
 699         bfd_h_get_size
 700
 701 DESCRIPTION
 702         These macros have the same function as their <<bfd_get_x>>
 703         bretheren, except that they are used for removing information
 704         for the header records of object files. Believe it or not,
 705         some object files keep their header records in big endian
 706         order and their data in little endian order.
 707 .
 708 .{* Byte swapping macros for file header data.  *}
 709 .
 710 .#define bfd_h_put_8(abfd, val, ptr) \
 711 .               bfd_put_8 (abfd, val, ptr)
 712 .#define bfd_h_put_signed_8(abfd, val, ptr) \
 713 .               bfd_put_8 (abfd, val, ptr)
 714 .#define bfd_h_get_8(abfd, ptr) \
 715 .               bfd_get_8 (abfd, ptr)
 716 .#define bfd_h_get_signed_8(abfd, ptr) \
 717 .               bfd_get_signed_8 (abfd, ptr)
 718 .
 719 .#define bfd_h_put_16(abfd, val, ptr) \
 720 .                BFD_SEND(abfd, bfd_h_putx16,(val,ptr))
 721 .#define bfd_h_put_signed_16 \
 722 .                bfd_h_put_16
 723 .#define bfd_h_get_16(abfd, ptr) \
 724 .                BFD_SEND(abfd, bfd_h_getx16,(ptr))
 725 .#define bfd_h_get_signed_16(abfd, ptr) \
 726 .                BFD_SEND(abfd, bfd_h_getx_signed_16, (ptr))
 727 .
 728 .#define bfd_h_put_32(abfd, val, ptr) \
 729 .                BFD_SEND(abfd, bfd_h_putx32,(val,ptr))
 730 .#define bfd_h_put_signed_32 \
 731 .                bfd_h_put_32
 732 .#define bfd_h_get_32(abfd, ptr) \
 733 .                BFD_SEND(abfd, bfd_h_getx32,(ptr))
 734 .#define bfd_h_get_signed_32(abfd, ptr) \
 735 .                BFD_SEND(abfd, bfd_h_getx_signed_32, (ptr))
 736 .
 737 .#define bfd_h_put_64(abfd, val, ptr) \
 738 .                BFD_SEND(abfd, bfd_h_putx64,(val, ptr))
 739 .#define bfd_h_put_signed_64 \
 740 .                bfd_h_put_64
 741 .#define bfd_h_get_64(abfd, ptr) \
 742 .                BFD_SEND(abfd, bfd_h_getx64,(ptr))
 743 .#define bfd_h_get_signed_64(abfd, ptr) \
 744 .                BFD_SEND(abfd, bfd_h_getx_signed_64, (ptr))
 745 .
 746 */
 747
 748 /* Sign extension to bfd_signed_vma.  */
 749 #define COERCE16(x) (((bfd_signed_vma) (x) ^ 0x8000) - 0x8000)
 750 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
 751 #define EIGHT_GAZILLION (((BFD_HOST_64_BIT)0x80000000) << 32)
 752 #define COERCE64(x) \
 753   (((bfd_signed_vma) (x) ^ EIGHT_GAZILLION) - EIGHT_GAZILLION)
 754
 755 bfd_vma
 756 bfd_getb16 (addr)
 757      register const bfd_byte *addr;
 758 {
 759   return (addr[0] << 8) | addr[1];
 760 }
 761
 762 bfd_vma
 763 bfd_getl16 (addr)
 764      register const bfd_byte *addr;
 765 {
 766   return (addr[1] << 8) | addr[0];
 767 }
 768
 769 bfd_signed_vma
 770 bfd_getb_signed_16 (addr)
 771      register const bfd_byte *addr;
 772 {
 773   return COERCE16((addr[0] << 8) | addr[1]);
 774 }
 775
 776 bfd_signed_vma
 777 bfd_getl_signed_16 (addr)
 778      register const bfd_byte *addr;
 779 {
 780   return COERCE16((addr[1] << 8) | addr[0]);
 781 }
 782
 783 void
 784 bfd_putb16 (data, addr)
 785      bfd_vma data;
 786      register bfd_byte *addr;
 787 {
 788   addr[0] = (bfd_byte)(data >> 8);
 789   addr[1] = (bfd_byte )data;
 790 }
 791
 792 void
 793 bfd_putl16 (data, addr)
 794      bfd_vma data;
 795      register bfd_byte *addr;
 796 {
 797   addr[0] = (bfd_byte )data;
 798   addr[1] = (bfd_byte)(data >> 8);
 799 }
 800
 801 bfd_vma
 802 bfd_getb32 (addr)
 803      register const bfd_byte *addr;
 804 {
 805   return (((((bfd_vma)addr[0] << 8) | addr[1]) << 8)
 806           | addr[2]) << 8 | addr[3];
 807 }
 808
 809 bfd_vma
 810 bfd_getl32 (addr)
 811      register const bfd_byte *addr;
 812 {
 813   return (((((bfd_vma)addr[3] << 8) | addr[2]) << 8)
 814           | addr[1]) << 8 | addr[0];
 815 }
 816
 817 bfd_signed_vma
 818 bfd_getb_signed_32 (addr)
 819      register const bfd_byte *addr;
 820 {
 821   return COERCE32((((((bfd_vma)addr[0] << 8) | addr[1]) << 8)
 822                    | addr[2]) << 8 | addr[3]);
 823 }
 824
 825 bfd_signed_vma
 826 bfd_getl_signed_32 (addr)
 827      register const bfd_byte *addr;
 828 {
 829   return COERCE32((((((bfd_vma)addr[3] << 8) | addr[2]) << 8)
 830                    | addr[1]) << 8 | addr[0]);
 831 }
 832
 833 bfd_vma
 834 bfd_getb64 (addr)
 835      register const bfd_byte *addr;
 836 {
 837 #ifdef BFD64
 838   bfd_vma low, high;
 839
 840   high= ((((((((addr[0]) << 8) |
 841               addr[1]) << 8) |
 842             addr[2]) << 8) |
 843           addr[3]) );
 844
 845   low = (((((((((bfd_vma)addr[4]) << 8) |
 846               addr[5]) << 8) |
 847             addr[6]) << 8) |
 848           addr[7]));
 849
 850   return high << 32 | low;
 851 #else
 852   BFD_FAIL();
 853   return 0;
 854 #endif
 855 }
 856
 857 bfd_vma
 858 bfd_getl64 (addr)
 859      register const bfd_byte *addr;
 860 {
 861 #ifdef BFD64
 862   bfd_vma low, high;
 863   high= (((((((addr[7] << 8) |
 864               addr[6]) << 8) |
 865             addr[5]) << 8) |
 866           addr[4]));
 867
 868   low = ((((((((bfd_vma)addr[3] << 8) |
 869               addr[2]) << 8) |
 870             addr[1]) << 8) |
 871           addr[0]) );
 872
 873   return high << 32 | low;
 874 #else
 875   BFD_FAIL();
 876   return 0;
 877 #endif
 878
 879 }
 880
 881 bfd_signed_vma
 882 bfd_getb_signed_64 (addr)
 883      register const bfd_byte *addr;
 884 {
 885 #ifdef BFD64
 886   bfd_vma low, high;
 887
 888   high= ((((((((addr[0]) << 8) |
 889               addr[1]) << 8) |
 890             addr[2]) << 8) |
 891           addr[3]) );
 892
 893   low = (((((((((bfd_vma)addr[4]) << 8) |
 894               addr[5]) << 8) |
 895             addr[6]) << 8) |
 896           addr[7]));
 897
 898   return COERCE64(high << 32 | low);
 899 #else
 900   BFD_FAIL();
 901   return 0;
 902 #endif
 903 }
 904
 905 bfd_signed_vma
 906 bfd_getl_signed_64 (addr)
 907      register const bfd_byte *addr;
 908 {
 909 #ifdef BFD64
 910   bfd_vma low, high;
 911   high= (((((((addr[7] << 8) |
 912               addr[6]) << 8) |
 913             addr[5]) << 8) |
 914           addr[4]));
 915
 916   low = ((((((((bfd_vma)addr[3] << 8) |
 917               addr[2]) << 8) |
 918             addr[1]) << 8) |
 919           addr[0]) );
 920
 921   return COERCE64(high << 32 | low);
 922 #else
 923   BFD_FAIL();
 924   return 0;
 925 #endif
 926 }
 927
 928 void
 929 bfd_putb32 (data, addr)
 930      bfd_vma data;
 931      register bfd_byte *addr;
 932 {
 933         addr[0] = (bfd_byte)(data >> 24);
 934         addr[1] = (bfd_byte)(data >> 16);
 935         addr[2] = (bfd_byte)(data >>  8);
 936         addr[3] = (bfd_byte)data;
 937 }
 938
 939 void
 940 bfd_putl32 (data, addr)
 941      bfd_vma data;
 942      register bfd_byte *addr;
 943 {
 944         addr[0] = (bfd_byte)data;
 945         addr[1] = (bfd_byte)(data >>  8);
 946         addr[2] = (bfd_byte)(data >> 16);
 947         addr[3] = (bfd_byte)(data >> 24);
 948 }
 949
 950 void
 951 bfd_putb64 (data, addr)
 952      bfd_vma data;
 953      register bfd_byte *addr;
 954 {
 955 #ifdef BFD64
 956   addr[0] = (bfd_byte)(data >> (7*8));
 957   addr[1] = (bfd_byte)(data >> (6*8));
 958   addr[2] = (bfd_byte)(data >> (5*8));
 959   addr[3] = (bfd_byte)(data >> (4*8));
 960   addr[4] = (bfd_byte)(data >> (3*8));
 961   addr[5] = (bfd_byte)(data >> (2*8));
 962   addr[6] = (bfd_byte)(data >> (1*8));
 963   addr[7] = (bfd_byte)(data >> (0*8));
 964 #else
 965   BFD_FAIL();
 966 #endif
 967 }
 968
 969 void
 970 bfd_putl64 (data, addr)
 971      bfd_vma data;
 972      register bfd_byte *addr;
 973 {
 974 #ifdef BFD64
 975   addr[7] = (bfd_byte)(data >> (7*8));
 976   addr[6] = (bfd_byte)(data >> (6*8));
 977   addr[5] = (bfd_byte)(data >> (5*8));
 978   addr[4] = (bfd_byte)(data >> (4*8));
 979   addr[3] = (bfd_byte)(data >> (3*8));
 980   addr[2] = (bfd_byte)(data >> (2*8));
 981   addr[1] = (bfd_byte)(data >> (1*8));
 982   addr[0] = (bfd_byte)(data >> (0*8));
 983 #else
 984   BFD_FAIL();
 985 #endif
 986 }
 987 \f
 988 /* Default implementation */
 989
 990 boolean
 991 _bfd_generic_get_section_contents (abfd, section, location, offset, count)
 992      bfd *abfd;
 993      sec_ptr section;
 994      PTR location;
 995      file_ptr offset;
 996      bfd_size_type count;
 997 {
 998     if (count == 0)
 999         return true;
1000     if ((bfd_size_type)(offset+count) > section->_raw_size
1001         || bfd_seek(abfd, (file_ptr)(section->filepos + offset), SEEK_SET) == -1
1002         || bfd_read(location, (bfd_size_type)1, count, abfd) != count)
1003         return (false); /* on error */
1004     return (true);
1005 }
1006
1007 boolean
1008 _bfd_generic_get_section_contents_in_window (abfd, section, w, offset, count)
1009      bfd *abfd;
1010      sec_ptr section;
1011      bfd_window *w;
1012      file_ptr offset;
1013      bfd_size_type count;
1014 {
1015   if (count == 0)
1016     return true;
1017   if (abfd->xvec->_bfd_get_section_contents != _bfd_generic_get_section_contents)
1018     {
1019       /* We don't know what changes the bfd's get_section_contents
1020          method may have to make.  So punt trying to map the file
1021          window, and let get_section_contents do its thing.  */
1022       /* @@ FIXME : If the internal window has a refcount of 1 and was
1023          allocated with malloc instead of mmap, just reuse it.  */
1024       bfd_free_window (w);
1025       w->i = (bfd_window_internal *) bfd_zmalloc (sizeof (bfd_window_internal));
1026       if (w->i == NULL)
1027         return false;
1028       w->i->data = (PTR) malloc ((size_t) count);
1029       if (w->i->data == NULL)
1030         {
1031           free (w->i);
1032           w->i = NULL;
1033           return false;
1034         }
1035       w->i->mapped = 0;
1036       w->i->refcount = 1;
1037       w->size = w->i->size = count;
1038       w->data = w->i->data;
1039       return bfd_get_section_contents (abfd, section, w->data, offset, count);
1040     }
1041   if ((bfd_size_type) (offset+count) > section->_raw_size
1042       || (bfd_get_file_window (abfd, section->filepos + offset, count, w, 1)
1043           == false))
1044     return false;
1045   return true;
1046 }
1047
1048 /* This generic function can only be used in implementations where creating
1049    NEW sections is disallowed.  It is useful in patching existing sections
1050    in read-write files, though.  See other set_section_contents functions
1051    to see why it doesn't work for new sections.  */
1052 boolean
1053 _bfd_generic_set_section_contents (abfd, section, location, offset, count)
1054      bfd *abfd;
1055      sec_ptr section;
1056      PTR location;
1057      file_ptr offset;
1058      bfd_size_type count;
1059 {
1060   if (count == 0)
1061     return true;
1062
1063   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) == -1
1064       || bfd_write (location, (bfd_size_type) 1, count, abfd) != count)
1065     return false;
1066
1067   return true;
1068 }
1069
1070 /*
1071 INTERNAL_FUNCTION
1072         bfd_log2
1073
1074 SYNOPSIS
1075         unsigned int bfd_log2(bfd_vma x);
1076
1077 DESCRIPTION
1078         Return the log base 2 of the value supplied, rounded up.  E.g., an
1079         @var{x} of 1025 returns 11.
1080 */
1081
1082 unsigned
1083 bfd_log2(x)
1084      bfd_vma x;
1085 {
1086   unsigned result = 0;
1087   while ( (bfd_vma)(1<< result) < x)
1088     result++;
1089   return result;
1090 }
1091
1092 boolean
1093 bfd_generic_is_local_label (abfd, sym)
1094      bfd *abfd;
1095      asymbol *sym;
1096 {
1097   char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
1098
1099   return (sym->name[0] == locals_prefix);
1100 }
1101