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      boolean 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
 371                        ? MAP_FILE | MAP_PRIVATE
 372                        : MAP_FILE | MAP_SHARED),
 373                       fd, file_offset);
 374       if (i->data == (PTR) -1)
 375         {
 376           /* An error happened.  Report it, or try using malloc, or
 377              something.  */
 378           bfd_set_error (bfd_error_system_call);
 379           i->data = 0;
 380           windowp->data = 0;
 381           if (debug_windows)
 382             fprintf (stderr, "\t\tmmap failed!\n");
 383           return false;
 384         }
 385       if (debug_windows)
 386         fprintf (stderr, "\n\tmapped %ld at %p, offset is %ld\n",
 387                  (long) real_size, i->data, (long) offset2);
 388       i->size = real_size;
 389       windowp->data = i->data + offset2;
 390       windowp->size = size;
 391       i->mapped = 1;
 392       return true;
 393     }
 394   else if (debug_windows)
 395     {
 396       if (ok_to_map)
 397         fprintf (stderr, "not mapping: data=%x mapped=%d\n",
 398                  i->data, (int) i->mapped);
 399       else
 400         fprintf (stderr, "not mapping: env var not set\n");
 401     }
 402 #else
 403   ok_to_map = 0;
 404 #endif
 405
 406 #ifdef HAVE_MPROTECT
 407   if (!writable)
 408     {
 409       size_to_alloc += pagesize - 1;
 410       size_to_alloc -= size_to_alloc % pagesize;
 411     }
 412 #endif
 413   if (debug_windows)
 414     fprintf (stderr, "\n\t%s(%6ld)",
 415              i->data ? "realloc" : " malloc", (long) size_to_alloc);
 416   if (i->data)
 417     i->data = (PTR) realloc (i->data, size_to_alloc);
 418   else
 419     i->data = (PTR) malloc (size_to_alloc);
 420   if (debug_windows)
 421     fprintf (stderr, "\t-> %p\n", i->data);
 422   i->refcount = 1;
 423   if (i->data == NULL)
 424     {
 425       if (size_to_alloc == 0)
 426         return true;
 427       bfd_set_error (bfd_error_no_memory);
 428       return false;
 429     }
 430   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
 431     return false;
 432   i->size = bfd_read (i->data, size, 1, abfd);
 433   if (i->size != size)
 434     return false;
 435   i->mapped = 0;
 436 #ifdef HAVE_MPROTECT
 437   if (!writable)
 438     {
 439       if (debug_windows)
 440         fprintf (stderr, "\tmprotect (%p, %ld, PROT_READ)\n", i->data,
 441                  (long) i->size);
 442       mprotect (i->data, i->size, PROT_READ);
 443     }
 444 #endif
 445   windowp->data = i->data;
 446   windowp->size = i->size;
 447   return true;
 448 }
 449
 450 bfd_size_type
 451 bfd_write (ptr, size, nitems, abfd)
 452      CONST PTR ptr;
 453      bfd_size_type size;
 454      bfd_size_type nitems;
 455      bfd *abfd;
 456 {
 457   long nwrote = fwrite (ptr, 1, (size_t) (size * nitems),
 458                         bfd_cache_lookup (abfd));
 459 #ifdef FILE_OFFSET_IS_CHAR_INDEX
 460   if (nwrote > 0)
 461     abfd->where += nwrote;
 462 #endif
 463   if ((bfd_size_type) nwrote != size * nitems)
 464     {
 465 #ifdef ENOSPC
 466       if (nwrote >= 0)
 467         errno = ENOSPC;
 468 #endif
 469       bfd_set_error (bfd_error_system_call);
 470     }
 471   return nwrote;
 472 }
 473
 474 /*
 475 INTERNAL_FUNCTION
 476         bfd_write_bigendian_4byte_int
 477
 478 SYNOPSIS
 479         void bfd_write_bigendian_4byte_int(bfd *abfd,  int i);
 480
 481 DESCRIPTION
 482         Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
 483         endian order regardless of what else is going on.  This is useful in
 484         archives.
 485
 486 */
 487 void
 488 bfd_write_bigendian_4byte_int (abfd, i)
 489      bfd *abfd;
 490      int i;
 491 {
 492   bfd_byte buffer[4];
 493   bfd_putb32(i, buffer);
 494   if (bfd_write((PTR)buffer, 4, 1, abfd) != 4)
 495     abort ();
 496 }
 497
 498 long
 499 bfd_tell (abfd)
 500      bfd *abfd;
 501 {
 502   file_ptr ptr;
 503
 504   ptr = ftell (bfd_cache_lookup(abfd));
 505
 506   if (abfd->my_archive)
 507     ptr -= abfd->origin;
 508   abfd->where = ptr;
 509   return ptr;
 510 }
 511
 512 int
 513 bfd_flush (abfd)
 514      bfd *abfd;
 515 {
 516   return fflush (bfd_cache_lookup(abfd));
 517 }
 518
 519 /* Returns 0 for success, negative value for failure (in which case
 520    bfd_get_error can retrieve the error code).  */
 521 int
 522 bfd_stat (abfd, statbuf)
 523      bfd *abfd;
 524      struct stat *statbuf;
 525 {
 526   FILE *f;
 527   int result;
 528   f = bfd_cache_lookup (abfd);
 529   if (f == NULL)
 530     {
 531       bfd_set_error (bfd_error_system_call);
 532       return -1;
 533     }
 534   result = fstat (fileno (f), statbuf);
 535   if (result < 0)
 536     bfd_set_error (bfd_error_system_call);
 537   return result;
 538 }
 539
 540 /* Returns 0 for success, nonzero for failure (in which case bfd_get_error
 541    can retrieve the error code).  */
 542
 543 int
 544 bfd_seek (abfd, position, direction)
 545      bfd *abfd;
 546      file_ptr position;
 547      int direction;
 548 {
 549   int result;
 550   FILE *f;
 551   file_ptr file_position;
 552   /* For the time being, a BFD may not seek to it's end.  The problem
 553      is that we don't easily have a way to recognize the end of an
 554      element in an archive. */
 555
 556   BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);
 557
 558   if (direction == SEEK_CUR && position == 0)
 559     return 0;
 560 #ifdef FILE_OFFSET_IS_CHAR_INDEX
 561   if (abfd->format != bfd_archive && abfd->my_archive == 0)
 562     {
 563 #if 0
 564       /* Explanation for this code: I'm only about 95+% sure that the above
 565          conditions are sufficient and that all i/o calls are properly
 566          adjusting the `where' field.  So this is sort of an `assert'
 567          that the `where' field is correct.  If we can go a while without
 568          tripping the abort, we can probably safely disable this code,
 569          so that the real optimizations happen.  */
 570       file_ptr where_am_i_now;
 571       where_am_i_now = ftell (bfd_cache_lookup (abfd));
 572       if (abfd->my_archive)
 573         where_am_i_now -= abfd->origin;
 574       if (where_am_i_now != abfd->where)
 575         abort ();
 576 #endif
 577       if (direction == SEEK_SET && position == abfd->where)
 578         return 0;
 579     }
 580   else
 581     {
 582       /* We need something smarter to optimize access to archives.
 583          Currently, anything inside an archive is read via the file
 584          handle for the archive.  Which means that a bfd_seek on one
 585          component affects the `current position' in the archive, as
 586          well as in any other component.
 587
 588          It might be sufficient to put a spike through the cache
 589          abstraction, and look to the archive for the file position,
 590          but I think we should try for something cleaner.
 591
 592          In the meantime, no optimization for archives.  */
 593     }
 594 #endif
 595
 596   f = bfd_cache_lookup (abfd);
 597   file_position = position;
 598   if (direction == SEEK_SET && abfd->my_archive != NULL)
 599     file_position += abfd->origin;
 600
 601   result = fseek (f, file_position, direction);
 602
 603   if (result != 0)
 604     {
 605       /* Force redetermination of `where' field.  */
 606       bfd_tell (abfd);
 607       bfd_set_error (bfd_error_system_call);
 608     }
 609   else
 610     {
 611 #ifdef FILE_OFFSET_IS_CHAR_INDEX
 612       /* Adjust `where' field.  */
 613       if (direction == SEEK_SET)
 614         abfd->where = position;
 615       else
 616         abfd->where += position;
 617 #endif
 618     }
 619   return result;
 620 }
 621 \f
 622 /** The do-it-yourself (byte) sex-change kit */
 623
 624 /* The middle letter e.g. get<b>short indicates Big or Little endian
 625    target machine.  It doesn't matter what the byte order of the host
 626    machine is; these routines work for either.  */
 627
 628 /* FIXME: Should these take a count argument?
 629    Answer (gnu@cygnus.com):  No, but perhaps they should be inline
 630                              functions in swap.h #ifdef __GNUC__.
 631                              Gprof them later and find out.  */
 632
 633 /*
 634 FUNCTION
 635         bfd_put_size
 636 FUNCTION
 637         bfd_get_size
 638
 639 DESCRIPTION
 640         These macros as used for reading and writing raw data in
 641         sections; each access (except for bytes) is vectored through
 642         the target format of the BFD and mangled accordingly. The
 643         mangling performs any necessary endian translations and
 644         removes alignment restrictions.  Note that types accepted and
 645         returned by these macros are identical so they can be swapped
 646         around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
 647         to either <<bfd_get_32>> or <<bfd_get_64>>.
 648
 649         In the put routines, @var{val} must be a <<bfd_vma>>.  If we are on a
 650         system without prototypes, the caller is responsible for making
 651         sure that is true, with a cast if necessary.  We don't cast
 652         them in the macro definitions because that would prevent <<lint>>
 653         or <<gcc -Wall>> from detecting sins such as passing a pointer.
 654         To detect calling these with less than a <<bfd_vma>>, use
 655         <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
 656
 657 .
 658 .{* Byte swapping macros for user section data.  *}
 659 .
 660 .#define bfd_put_8(abfd, val, ptr) \
 661 .                (*((unsigned char *)(ptr)) = (unsigned char)(val))
 662 .#define bfd_put_signed_8 \
 663 .               bfd_put_8
 664 .#define bfd_get_8(abfd, ptr) \
 665 .                (*(unsigned char *)(ptr))
 666 .#define bfd_get_signed_8(abfd, ptr) \
 667 .               ((*(unsigned char *)(ptr) ^ 0x80) - 0x80)
 668 .
 669 .#define bfd_put_16(abfd, val, ptr) \
 670 .                BFD_SEND(abfd, bfd_putx16, ((val),(ptr)))
 671 .#define bfd_put_signed_16 \
 672 .                bfd_put_16
 673 .#define bfd_get_16(abfd, ptr) \
 674 .                BFD_SEND(abfd, bfd_getx16, (ptr))
 675 .#define bfd_get_signed_16(abfd, ptr) \
 676 .                BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
 677 .
 678 .#define bfd_put_32(abfd, val, ptr) \
 679 .                BFD_SEND(abfd, bfd_putx32, ((val),(ptr)))
 680 .#define bfd_put_signed_32 \
 681 .                bfd_put_32
 682 .#define bfd_get_32(abfd, ptr) \
 683 .                BFD_SEND(abfd, bfd_getx32, (ptr))
 684 .#define bfd_get_signed_32(abfd, ptr) \
 685 .                BFD_SEND(abfd, bfd_getx_signed_32, (ptr))
 686 .
 687 .#define bfd_put_64(abfd, val, ptr) \
 688 .                BFD_SEND(abfd, bfd_putx64, ((val), (ptr)))
 689 .#define bfd_put_signed_64 \
 690 .                bfd_put_64
 691 .#define bfd_get_64(abfd, ptr) \
 692 .                BFD_SEND(abfd, bfd_getx64, (ptr))
 693 .#define bfd_get_signed_64(abfd, ptr) \
 694 .                BFD_SEND(abfd, bfd_getx_signed_64, (ptr))
 695 .
 696 */
 697
 698 /*
 699 FUNCTION
 700         bfd_h_put_size
 701         bfd_h_get_size
 702
 703 DESCRIPTION
 704         These macros have the same function as their <<bfd_get_x>>
 705         bretheren, except that they are used for removing information
 706         for the header records of object files. Believe it or not,
 707         some object files keep their header records in big endian
 708         order and their data in little endian order.
 709 .
 710 .{* Byte swapping macros for file header data.  *}
 711 .
 712 .#define bfd_h_put_8(abfd, val, ptr) \
 713 .               bfd_put_8 (abfd, val, ptr)
 714 .#define bfd_h_put_signed_8(abfd, val, ptr) \
 715 .               bfd_put_8 (abfd, val, ptr)
 716 .#define bfd_h_get_8(abfd, ptr) \
 717 .               bfd_get_8 (abfd, ptr)
 718 .#define bfd_h_get_signed_8(abfd, ptr) \
 719 .               bfd_get_signed_8 (abfd, ptr)
 720 .
 721 .#define bfd_h_put_16(abfd, val, ptr) \
 722 .                BFD_SEND(abfd, bfd_h_putx16,(val,ptr))
 723 .#define bfd_h_put_signed_16 \
 724 .                bfd_h_put_16
 725 .#define bfd_h_get_16(abfd, ptr) \
 726 .                BFD_SEND(abfd, bfd_h_getx16,(ptr))
 727 .#define bfd_h_get_signed_16(abfd, ptr) \
 728 .                BFD_SEND(abfd, bfd_h_getx_signed_16, (ptr))
 729 .
 730 .#define bfd_h_put_32(abfd, val, ptr) \
 731 .                BFD_SEND(abfd, bfd_h_putx32,(val,ptr))
 732 .#define bfd_h_put_signed_32 \
 733 .                bfd_h_put_32
 734 .#define bfd_h_get_32(abfd, ptr) \
 735 .                BFD_SEND(abfd, bfd_h_getx32,(ptr))
 736 .#define bfd_h_get_signed_32(abfd, ptr) \
 737 .                BFD_SEND(abfd, bfd_h_getx_signed_32, (ptr))
 738 .
 739 .#define bfd_h_put_64(abfd, val, ptr) \
 740 .                BFD_SEND(abfd, bfd_h_putx64,(val, ptr))
 741 .#define bfd_h_put_signed_64 \
 742 .                bfd_h_put_64
 743 .#define bfd_h_get_64(abfd, ptr) \
 744 .                BFD_SEND(abfd, bfd_h_getx64,(ptr))
 745 .#define bfd_h_get_signed_64(abfd, ptr) \
 746 .                BFD_SEND(abfd, bfd_h_getx_signed_64, (ptr))
 747 .
 748 */
 749
 750 /* Sign extension to bfd_signed_vma.  */
 751 #define COERCE16(x) (((bfd_signed_vma) (x) ^ 0x8000) - 0x8000)
 752 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
 753 #define EIGHT_GAZILLION (((BFD_HOST_64_BIT)0x80000000) << 32)
 754 #define COERCE64(x) \
 755   (((bfd_signed_vma) (x) ^ EIGHT_GAZILLION) - EIGHT_GAZILLION)
 756
 757 bfd_vma
 758 bfd_getb16 (addr)
 759      register const bfd_byte *addr;
 760 {
 761   return (addr[0] << 8) | addr[1];
 762 }
 763
 764 bfd_vma
 765 bfd_getl16 (addr)
 766      register const bfd_byte *addr;
 767 {
 768   return (addr[1] << 8) | addr[0];
 769 }
 770
 771 bfd_signed_vma
 772 bfd_getb_signed_16 (addr)
 773      register const bfd_byte *addr;
 774 {
 775   return COERCE16((addr[0] << 8) | addr[1]);
 776 }
 777
 778 bfd_signed_vma
 779 bfd_getl_signed_16 (addr)
 780      register const bfd_byte *addr;
 781 {
 782   return COERCE16((addr[1] << 8) | addr[0]);
 783 }
 784
 785 void
 786 bfd_putb16 (data, addr)
 787      bfd_vma data;
 788      register bfd_byte *addr;
 789 {
 790   addr[0] = (bfd_byte)(data >> 8);
 791   addr[1] = (bfd_byte )data;
 792 }
 793
 794 void
 795 bfd_putl16 (data, addr)
 796      bfd_vma data;
 797      register bfd_byte *addr;
 798 {
 799   addr[0] = (bfd_byte )data;
 800   addr[1] = (bfd_byte)(data >> 8);
 801 }
 802
 803 bfd_vma
 804 bfd_getb32 (addr)
 805      register const bfd_byte *addr;
 806 {
 807   return (((((bfd_vma)addr[0] << 8) | addr[1]) << 8)
 808           | addr[2]) << 8 | addr[3];
 809 }
 810
 811 bfd_vma
 812 bfd_getl32 (addr)
 813      register const bfd_byte *addr;
 814 {
 815   return (((((bfd_vma)addr[3] << 8) | addr[2]) << 8)
 816           | addr[1]) << 8 | addr[0];
 817 }
 818
 819 bfd_signed_vma
 820 bfd_getb_signed_32 (addr)
 821      register const bfd_byte *addr;
 822 {
 823   return COERCE32((((((bfd_vma)addr[0] << 8) | addr[1]) << 8)
 824                    | addr[2]) << 8 | addr[3]);
 825 }
 826
 827 bfd_signed_vma
 828 bfd_getl_signed_32 (addr)
 829      register const bfd_byte *addr;
 830 {
 831   return COERCE32((((((bfd_vma)addr[3] << 8) | addr[2]) << 8)
 832                    | addr[1]) << 8 | addr[0]);
 833 }
 834
 835 bfd_vma
 836 bfd_getb64 (addr)
 837      register const bfd_byte *addr;
 838 {
 839 #ifdef BFD64
 840   bfd_vma low, high;
 841
 842   high= ((((((((addr[0]) << 8) |
 843               addr[1]) << 8) |
 844             addr[2]) << 8) |
 845           addr[3]) );
 846
 847   low = (((((((((bfd_vma)addr[4]) << 8) |
 848               addr[5]) << 8) |
 849             addr[6]) << 8) |
 850           addr[7]));
 851
 852   return high << 32 | low;
 853 #else
 854   BFD_FAIL();
 855   return 0;
 856 #endif
 857 }
 858
 859 bfd_vma
 860 bfd_getl64 (addr)
 861      register const bfd_byte *addr;
 862 {
 863 #ifdef BFD64
 864   bfd_vma low, high;
 865   high= (((((((addr[7] << 8) |
 866               addr[6]) << 8) |
 867             addr[5]) << 8) |
 868           addr[4]));
 869
 870   low = ((((((((bfd_vma)addr[3] << 8) |
 871               addr[2]) << 8) |
 872             addr[1]) << 8) |
 873           addr[0]) );
 874
 875   return high << 32 | low;
 876 #else
 877   BFD_FAIL();
 878   return 0;
 879 #endif
 880
 881 }
 882
 883 bfd_signed_vma
 884 bfd_getb_signed_64 (addr)
 885      register const bfd_byte *addr;
 886 {
 887 #ifdef BFD64
 888   bfd_vma low, high;
 889
 890   high= ((((((((addr[0]) << 8) |
 891               addr[1]) << 8) |
 892             addr[2]) << 8) |
 893           addr[3]) );
 894
 895   low = (((((((((bfd_vma)addr[4]) << 8) |
 896               addr[5]) << 8) |
 897             addr[6]) << 8) |
 898           addr[7]));
 899
 900   return COERCE64(high << 32 | low);
 901 #else
 902   BFD_FAIL();
 903   return 0;
 904 #endif
 905 }
 906
 907 bfd_signed_vma
 908 bfd_getl_signed_64 (addr)
 909      register const bfd_byte *addr;
 910 {
 911 #ifdef BFD64
 912   bfd_vma low, high;
 913   high= (((((((addr[7] << 8) |
 914               addr[6]) << 8) |
 915             addr[5]) << 8) |
 916           addr[4]));
 917
 918   low = ((((((((bfd_vma)addr[3] << 8) |
 919               addr[2]) << 8) |
 920             addr[1]) << 8) |
 921           addr[0]) );
 922
 923   return COERCE64(high << 32 | low);
 924 #else
 925   BFD_FAIL();
 926   return 0;
 927 #endif
 928 }
 929
 930 void
 931 bfd_putb32 (data, addr)
 932      bfd_vma data;
 933      register bfd_byte *addr;
 934 {
 935         addr[0] = (bfd_byte)(data >> 24);
 936         addr[1] = (bfd_byte)(data >> 16);
 937         addr[2] = (bfd_byte)(data >>  8);
 938         addr[3] = (bfd_byte)data;
 939 }
 940
 941 void
 942 bfd_putl32 (data, addr)
 943      bfd_vma data;
 944      register bfd_byte *addr;
 945 {
 946         addr[0] = (bfd_byte)data;
 947         addr[1] = (bfd_byte)(data >>  8);
 948         addr[2] = (bfd_byte)(data >> 16);
 949         addr[3] = (bfd_byte)(data >> 24);
 950 }
 951
 952 void
 953 bfd_putb64 (data, addr)
 954      bfd_vma data;
 955      register bfd_byte *addr;
 956 {
 957 #ifdef BFD64
 958   addr[0] = (bfd_byte)(data >> (7*8));
 959   addr[1] = (bfd_byte)(data >> (6*8));
 960   addr[2] = (bfd_byte)(data >> (5*8));
 961   addr[3] = (bfd_byte)(data >> (4*8));
 962   addr[4] = (bfd_byte)(data >> (3*8));
 963   addr[5] = (bfd_byte)(data >> (2*8));
 964   addr[6] = (bfd_byte)(data >> (1*8));
 965   addr[7] = (bfd_byte)(data >> (0*8));
 966 #else
 967   BFD_FAIL();
 968 #endif
 969 }
 970
 971 void
 972 bfd_putl64 (data, addr)
 973      bfd_vma data;
 974      register bfd_byte *addr;
 975 {
 976 #ifdef BFD64
 977   addr[7] = (bfd_byte)(data >> (7*8));
 978   addr[6] = (bfd_byte)(data >> (6*8));
 979   addr[5] = (bfd_byte)(data >> (5*8));
 980   addr[4] = (bfd_byte)(data >> (4*8));
 981   addr[3] = (bfd_byte)(data >> (3*8));
 982   addr[2] = (bfd_byte)(data >> (2*8));
 983   addr[1] = (bfd_byte)(data >> (1*8));
 984   addr[0] = (bfd_byte)(data >> (0*8));
 985 #else
 986   BFD_FAIL();
 987 #endif
 988 }
 989 \f
 990 /* Default implementation */
 991
 992 boolean
 993 _bfd_generic_get_section_contents (abfd, section, location, offset, count)
 994      bfd *abfd;
 995      sec_ptr section;
 996      PTR location;
 997      file_ptr offset;
 998      bfd_size_type count;
 999 {
1000     if (count == 0)
1001         return true;
1002     if ((bfd_size_type)(offset+count) > section->_raw_size
1003         || bfd_seek(abfd, (file_ptr)(section->filepos + offset), SEEK_SET) == -1
1004         || bfd_read(location, (bfd_size_type)1, count, abfd) != count)
1005         return (false); /* on error */
1006     return (true);
1007 }
1008
1009 boolean
1010 _bfd_generic_get_section_contents_in_window (abfd, section, w, offset, count)
1011      bfd *abfd;
1012      sec_ptr section;
1013      bfd_window *w;
1014      file_ptr offset;
1015      bfd_size_type count;
1016 {
1017   if (count == 0)
1018     return true;
1019   if (abfd->xvec->_bfd_get_section_contents != _bfd_generic_get_section_contents)
1020     {
1021       /* We don't know what changes the bfd's get_section_contents
1022          method may have to make.  So punt trying to map the file
1023          window, and let get_section_contents do its thing.  */
1024       /* @@ FIXME : If the internal window has a refcount of 1 and was
1025          allocated with malloc instead of mmap, just reuse it.  */
1026       bfd_free_window (w);
1027       w->i = (bfd_window_internal *) bfd_zmalloc (sizeof (bfd_window_internal));
1028       if (w->i == NULL)
1029         return false;
1030       w->i->data = (PTR) malloc ((size_t) count);
1031       if (w->i->data == NULL)
1032         {
1033           free (w->i);
1034           w->i = NULL;
1035           return false;
1036         }
1037       w->i->mapped = 0;
1038       w->i->refcount = 1;
1039       w->size = w->i->size = count;
1040       w->data = w->i->data;
1041       return bfd_get_section_contents (abfd, section, w->data, offset, count);
1042     }
1043   if ((bfd_size_type) (offset+count) > section->_raw_size
1044       || (bfd_get_file_window (abfd, section->filepos + offset, count, w, true)
1045           == false))
1046     return false;
1047   return true;
1048 }
1049
1050 /* This generic function can only be used in implementations where creating
1051    NEW sections is disallowed.  It is useful in patching existing sections
1052    in read-write files, though.  See other set_section_contents functions
1053    to see why it doesn't work for new sections.  */
1054 boolean
1055 _bfd_generic_set_section_contents (abfd, section, location, offset, count)
1056      bfd *abfd;
1057      sec_ptr section;
1058      PTR location;
1059      file_ptr offset;
1060      bfd_size_type count;
1061 {
1062   if (count == 0)
1063     return true;
1064
1065   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) == -1
1066       || bfd_write (location, (bfd_size_type) 1, count, abfd) != count)
1067     return false;
1068
1069   return true;
1070 }
1071
1072 /*
1073 INTERNAL_FUNCTION
1074         bfd_log2
1075
1076 SYNOPSIS
1077         unsigned int bfd_log2(bfd_vma x);
1078
1079 DESCRIPTION
1080         Return the log base 2 of the value supplied, rounded up.  E.g., an
1081         @var{x} of 1025 returns 11.
1082 */
1083
1084 unsigned
1085 bfd_log2(x)
1086      bfd_vma x;
1087 {
1088   unsigned result = 0;
1089   while ( (bfd_vma)(1<< result) < x)
1090     result++;
1091   return result;
1092 }
1093
1094 boolean
1095 bfd_generic_is_local_label (abfd, sym)
1096      bfd *abfd;
1097      asymbol *sym;
1098 {
1099   char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
1100
1101   return (sym->name[0] == locals_prefix);
1102 }
1103