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
   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 static size_t real_read PARAMS ((PTR, size_t, size_t, FILE *));
  32
  33 /*
  34 SECTION
  35         Internal functions
  36
  37 DESCRIPTION
  38         These routines are used within BFD.
  39         They are not intended for export, but are documented here for
  40         completeness.
  41 */
  42
  43 /* A routine which is used in target vectors for unsupported
  44    operations.  */
  45
  46 boolean
  47 bfd_false (ignore)
  48      bfd *ignore ATTRIBUTE_UNUSED;
  49 {
  50   bfd_set_error (bfd_error_invalid_operation);
  51   return false;
  52 }
  53
  54 /* A routine which is used in target vectors for supported operations
  55    which do not actually do anything.  */
  56
  57 boolean
  58 bfd_true (ignore)
  59      bfd *ignore ATTRIBUTE_UNUSED;
  60 {
  61   return true;
  62 }
  63
  64 /* A routine which is used in target vectors for unsupported
  65    operations which return a pointer value.  */
  66
  67 PTR
  68 bfd_nullvoidptr (ignore)
  69      bfd *ignore ATTRIBUTE_UNUSED;
  70 {
  71   bfd_set_error (bfd_error_invalid_operation);
  72   return NULL;
  73 }
  74
  75 int
  76 bfd_0 (ignore)
  77      bfd *ignore ATTRIBUTE_UNUSED;
  78 {
  79   return 0;
  80 }
  81
  82 unsigned int
  83 bfd_0u (ignore)
  84      bfd *ignore ATTRIBUTE_UNUSED;
  85 {
  86    return 0;
  87 }
  88
  89 long
  90 bfd_0l (ignore)
  91      bfd *ignore ATTRIBUTE_UNUSED;
  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 long
 100 _bfd_n1 (ignore_abfd)
 101      bfd *ignore_abfd ATTRIBUTE_UNUSED;
 102 {
 103   bfd_set_error (bfd_error_invalid_operation);
 104   return -1;
 105 }
 106
 107 void
 108 bfd_void (ignore)
 109      bfd *ignore ATTRIBUTE_UNUSED;
 110 {
 111 }
 112
 113 boolean
 114 _bfd_nocore_core_file_matches_executable_p (ignore_core_bfd, ignore_exec_bfd)
 115      bfd *ignore_core_bfd ATTRIBUTE_UNUSED;
 116      bfd *ignore_exec_bfd ATTRIBUTE_UNUSED;
 117 {
 118   bfd_set_error (bfd_error_invalid_operation);
 119   return false;
 120 }
 121
 122 /* Routine to handle core_file_failing_command entry point for targets
 123    without core file support.  */
 124
 125 char *
 126 _bfd_nocore_core_file_failing_command (ignore_abfd)
 127      bfd *ignore_abfd ATTRIBUTE_UNUSED;
 128 {
 129   bfd_set_error (bfd_error_invalid_operation);
 130   return (char *)NULL;
 131 }
 132
 133 /* Routine to handle core_file_failing_signal entry point for targets
 134    without core file support.  */
 135
 136 int
 137 _bfd_nocore_core_file_failing_signal (ignore_abfd)
 138      bfd *ignore_abfd ATTRIBUTE_UNUSED;
 139 {
 140   bfd_set_error (bfd_error_invalid_operation);
 141   return 0;
 142 }
 143
 144 const bfd_target *
 145 _bfd_dummy_target (ignore_abfd)
 146      bfd *ignore_abfd ATTRIBUTE_UNUSED;
 147 {
 148   bfd_set_error (bfd_error_wrong_format);
 149   return 0;
 150 }
 151 \f
 152 /* Allocate memory using malloc.  */
 153
 154 PTR
 155 bfd_malloc (size)
 156      bfd_size_type size;
 157 {
 158   PTR ptr;
 159
 160   if (size != (size_t) size)
 161     {
 162       bfd_set_error (bfd_error_no_memory);
 163       return NULL;
 164     }
 165
 166   ptr = (PTR) malloc ((size_t) size);
 167   if (ptr == NULL && (size_t) size != 0)
 168     bfd_set_error (bfd_error_no_memory);
 169
 170   return ptr;
 171 }
 172
 173 /* Reallocate memory using realloc.  */
 174
 175 PTR
 176 bfd_realloc (ptr, size)
 177      PTR ptr;
 178      bfd_size_type size;
 179 {
 180   PTR ret;
 181
 182   if (size != (size_t) size)
 183     {
 184       bfd_set_error (bfd_error_no_memory);
 185       return NULL;
 186     }
 187
 188   if (ptr == NULL)
 189     ret = malloc ((size_t) size);
 190   else
 191     ret = realloc (ptr, (size_t) size);
 192
 193   if (ret == NULL && (size_t) size != 0)
 194     bfd_set_error (bfd_error_no_memory);
 195
 196   return ret;
 197 }
 198
 199 /* Allocate memory using malloc and clear it.  */
 200
 201 PTR
 202 bfd_zmalloc (size)
 203      bfd_size_type size;
 204 {
 205   PTR ptr;
 206
 207   if (size != (size_t) size)
 208     {
 209       bfd_set_error (bfd_error_no_memory);
 210       return NULL;
 211     }
 212
 213   ptr = (PTR) malloc ((size_t) size);
 214
 215   if ((size_t) size != 0)
 216     {
 217       if (ptr == NULL)
 218         bfd_set_error (bfd_error_no_memory);
 219       else
 220         memset (ptr, 0, (size_t) size);
 221     }
 222
 223   return ptr;
 224 }
 225 \f
 226 /* Some IO code */
 227
 228 /* Note that archive entries don't have streams; they share their parent's.
 229    This allows someone to play with the iostream behind BFD's back.
 230
 231    Also, note that the origin pointer points to the beginning of a file's
 232    contents (0 for non-archive elements).  For archive entries this is the
 233    first octet in the file, NOT the beginning of the archive header.  */
 234
 235 static size_t
 236 real_read (where, a, b, file)
 237      PTR where;
 238      size_t a;
 239      size_t b;
 240      FILE *file;
 241 {
 242   /* FIXME - this looks like an optimization, but it's really to cover
 243      up for a feature of some OSs (not solaris - sigh) that
 244      ld/pe-dll.c takes advantage of (apparently) when it creates BFDs
 245      internally and tries to link against them.  BFD seems to be smart
 246      enough to realize there are no symbol records in the "file" that
 247      doesn't exist but attempts to read them anyway.  On Solaris,
 248      attempting to read zero bytes from a NULL file results in a core
 249      dump, but on other platforms it just returns zero bytes read.
 250      This makes it to something reasonable. - DJ */
 251   if (a == 0 || b == 0)
 252     return 0;
 253
 254
 255 #if defined (__VAX) && defined (VMS)
 256   /* Apparently fread on Vax VMS does not keep the record length
 257      information.  */
 258   return read (fileno (file), where, a * b);
 259 #else
 260   return fread (where, a, b, file);
 261 #endif
 262 }
 263
 264 /* Return value is amount read.  */
 265
 266 bfd_size_type
 267 bfd_bread (ptr, size, abfd)
 268      PTR ptr;
 269      bfd_size_type size;
 270      bfd *abfd;
 271 {
 272   size_t nread;
 273
 274   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 275     {
 276       struct bfd_in_memory *bim;
 277       bfd_size_type get;
 278
 279       bim = (struct bfd_in_memory *) abfd->iostream;
 280       get = size;
 281       if (abfd->where + get > bim->size)
 282         {
 283           if (bim->size < (bfd_size_type) abfd->where)
 284             get = 0;
 285           else
 286             get = bim->size - abfd->where;
 287           bfd_set_error (bfd_error_file_truncated);
 288         }
 289       memcpy (ptr, bim->buffer + abfd->where, (size_t) get);
 290       abfd->where += get;
 291       return get;
 292     }
 293
 294   nread = real_read (ptr, 1, (size_t) size, bfd_cache_lookup (abfd));
 295   if (nread != (size_t) -1)
 296     abfd->where += nread;
 297
 298   /* Set bfd_error if we did not read as much data as we expected.
 299
 300      If the read failed due to an error set the bfd_error_system_call,
 301      else set bfd_error_file_truncated.
 302
 303      A BFD backend may wish to override bfd_error_file_truncated to
 304      provide something more useful (eg. no_symbols or wrong_format).  */
 305   if (nread != size)
 306     {
 307       if (ferror (bfd_cache_lookup (abfd)))
 308         bfd_set_error (bfd_error_system_call);
 309       else
 310         bfd_set_error (bfd_error_file_truncated);
 311     }
 312
 313   return nread;
 314 }
 315
 316 /* The window support stuff should probably be broken out into
 317    another file....  */
 318 /* The idea behind the next and refcount fields is that one mapped
 319    region can suffice for multiple read-only windows or multiple
 320    non-overlapping read-write windows.  It's not implemented yet
 321    though.  */
 322 struct _bfd_window_internal {
 323   struct _bfd_window_internal *next;
 324   PTR data;
 325   bfd_size_type size;
 326   int refcount : 31;            /* should be enough...  */
 327   unsigned mapped : 1;          /* 1 = mmap, 0 = malloc */
 328 };
 329
 330 void
 331 bfd_init_window (windowp)
 332      bfd_window *windowp;
 333 {
 334   windowp->data = 0;
 335   windowp->i = 0;
 336   windowp->size = 0;
 337 }
 338 \f
 339 /* Currently, if USE_MMAP is undefined, none if the window stuff is
 340    used.  Okay, so it's mis-named.  At least the command-line option
 341    "--without-mmap" is more obvious than "--without-windows" or some
 342    such.  */
 343 #ifdef USE_MMAP
 344
 345 #undef HAVE_MPROTECT /* code's not tested yet */
 346
 347 #if HAVE_MMAP || HAVE_MPROTECT || HAVE_MADVISE
 348 #include <sys/mman.h>
 349 #endif
 350
 351 #ifndef MAP_FILE
 352 #define MAP_FILE 0
 353 #endif
 354
 355 static int debug_windows;
 356
 357 void
 358 bfd_free_window (windowp)
 359      bfd_window *windowp;
 360 {
 361   bfd_window_internal *i = windowp->i;
 362   windowp->i = 0;
 363   windowp->data = 0;
 364   if (i == 0)
 365     return;
 366   i->refcount--;
 367   if (debug_windows)
 368     fprintf (stderr, "freeing window @%p<%p,%lx,%p>\n",
 369              windowp, windowp->data, windowp->size, windowp->i);
 370   if (i->refcount != 0)
 371     return;
 372
 373   if (i->mapped)
 374     {
 375 #ifdef HAVE_MMAP
 376       munmap (i->data, i->size);
 377       goto no_free;
 378 #else
 379       abort ();
 380 #endif
 381     }
 382 #ifdef HAVE_MPROTECT
 383   mprotect (i->data, i->size, PROT_READ | PROT_WRITE);
 384 #endif
 385   free (i->data);
 386 #ifdef HAVE_MMAP
 387  no_free:
 388 #endif
 389   i->data = 0;
 390   /* There should be no more references to i at this point.  */
 391   free (i);
 392 }
 393
 394 static int ok_to_map = 1;
 395
 396 boolean
 397 bfd_get_file_window (abfd, offset, size, windowp, writable)
 398      bfd *abfd;
 399      file_ptr offset;
 400      bfd_size_type size;
 401      bfd_window *windowp;
 402      boolean writable;
 403 {
 404   static size_t pagesize;
 405   bfd_window_internal *i = windowp->i;
 406   bfd_size_type size_to_alloc = size;
 407
 408   if (debug_windows)
 409     fprintf (stderr, "bfd_get_file_window (%p, %6ld, %6ld, %p<%p,%lx,%p>, %d)",
 410              abfd, (long) offset, (long) size,
 411              windowp, windowp->data, (unsigned long) windowp->size,
 412              windowp->i, writable);
 413
 414   /* Make sure we know the page size, so we can be friendly to mmap.  */
 415   if (pagesize == 0)
 416     pagesize = getpagesize ();
 417   if (pagesize == 0)
 418     abort ();
 419
 420   if (i == 0)
 421     {
 422       i = ((bfd_window_internal *)
 423            bfd_zmalloc ((bfd_size_type) sizeof (bfd_window_internal)));
 424       windowp->i = i;
 425       if (i == 0)
 426         return false;
 427       i->data = 0;
 428     }
 429 #ifdef HAVE_MMAP
 430   if (ok_to_map
 431       && (i->data == 0 || i->mapped == 1)
 432       && (abfd->flags & BFD_IN_MEMORY) == 0)
 433     {
 434       file_ptr file_offset, offset2;
 435       size_t real_size;
 436       int fd;
 437       FILE *f;
 438
 439       /* Find the real file and the real offset into it.  */
 440       while (abfd->my_archive != NULL)
 441         {
 442           offset += abfd->origin;
 443           abfd = abfd->my_archive;
 444         }
 445       f = bfd_cache_lookup (abfd);
 446       fd = fileno (f);
 447
 448       /* Compute offsets and size for mmap and for the user's data.  */
 449       offset2 = offset % pagesize;
 450       if (offset2 < 0)
 451         abort ();
 452       file_offset = offset - offset2;
 453       real_size = offset + size - file_offset;
 454       real_size = real_size + pagesize - 1;
 455       real_size -= real_size % pagesize;
 456
 457       /* If we're re-using a memory region, make sure it's big enough.  */
 458       if (i->data && i->size < size)
 459         {
 460           munmap (i->data, i->size);
 461           i->data = 0;
 462         }
 463       i->data = mmap (i->data, real_size,
 464                       writable ? PROT_WRITE | PROT_READ : PROT_READ,
 465                       (writable
 466                        ? MAP_FILE | MAP_PRIVATE
 467                        : MAP_FILE | MAP_SHARED),
 468                       fd, file_offset);
 469       if (i->data == (PTR) -1)
 470         {
 471           /* An error happened.  Report it, or try using malloc, or
 472              something.  */
 473           bfd_set_error (bfd_error_system_call);
 474           i->data = 0;
 475           windowp->data = 0;
 476           if (debug_windows)
 477             fprintf (stderr, "\t\tmmap failed!\n");
 478           return false;
 479         }
 480       if (debug_windows)
 481         fprintf (stderr, "\n\tmapped %ld at %p, offset is %ld\n",
 482                  (long) real_size, i->data, (long) offset2);
 483       i->size = real_size;
 484       windowp->data = (PTR) ((bfd_byte *) i->data + offset2);
 485       windowp->size = size;
 486       i->mapped = 1;
 487       return true;
 488     }
 489   else if (debug_windows)
 490     {
 491       if (ok_to_map)
 492         fprintf (stderr, _("not mapping: data=%lx mapped=%d\n"),
 493                  (unsigned long) i->data, (int) i->mapped);
 494       else
 495         fprintf (stderr, _("not mapping: env var not set\n"));
 496     }
 497 #else
 498   ok_to_map = 0;
 499 #endif
 500
 501 #ifdef HAVE_MPROTECT
 502   if (!writable)
 503     {
 504       size_to_alloc += pagesize - 1;
 505       size_to_alloc -= size_to_alloc % pagesize;
 506     }
 507 #endif
 508   if (debug_windows)
 509     fprintf (stderr, "\n\t%s(%6ld)",
 510              i->data ? "realloc" : " malloc", (long) size_to_alloc);
 511   i->data = (PTR) bfd_realloc (i->data, size_to_alloc);
 512   if (debug_windows)
 513     fprintf (stderr, "\t-> %p\n", i->data);
 514   i->refcount = 1;
 515   if (i->data == NULL)
 516     {
 517       if (size_to_alloc == 0)
 518         return true;
 519       return false;
 520     }
 521   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
 522     return false;
 523   i->size = bfd_bread (i->data, size, abfd);
 524   if (i->size != size)
 525     return false;
 526   i->mapped = 0;
 527 #ifdef HAVE_MPROTECT
 528   if (!writable)
 529     {
 530       if (debug_windows)
 531         fprintf (stderr, "\tmprotect (%p, %ld, PROT_READ)\n", i->data,
 532                  (long) i->size);
 533       mprotect (i->data, i->size, PROT_READ);
 534     }
 535 #endif
 536   windowp->data = i->data;
 537   windowp->size = i->size;
 538   return true;
 539 }
 540
 541 #endif /* USE_MMAP */
 542 \f
 543 bfd_size_type
 544 bfd_bwrite (ptr, size, abfd)
 545      const PTR ptr;
 546      bfd_size_type size;
 547      bfd *abfd;
 548 {
 549   size_t nwrote;
 550
 551   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 552     {
 553       struct bfd_in_memory *bim = (struct bfd_in_memory *) (abfd->iostream);
 554       size = (size_t) size;
 555       if (abfd->where + size > bim->size)
 556         {
 557           bfd_size_type newsize, oldsize;
 558
 559           oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
 560           bim->size = abfd->where + size;
 561           /* Round up to cut down on memory fragmentation */
 562           newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 563           if (newsize > oldsize)
 564             {
 565               bim->buffer = bfd_realloc (bim->buffer, newsize);
 566               if (bim->buffer == 0)
 567                 {
 568                   bim->size = 0;
 569                   return 0;
 570                 }
 571             }
 572         }
 573       memcpy (bim->buffer + abfd->where, ptr, (size_t) size);
 574       abfd->where += size;
 575       return size;
 576     }
 577
 578   nwrote = fwrite (ptr, 1, (size_t) size, bfd_cache_lookup (abfd));
 579   if (nwrote != (size_t) -1)
 580     abfd->where += nwrote;
 581   if (nwrote != size)
 582     {
 583 #ifdef ENOSPC
 584       errno = ENOSPC;
 585 #endif
 586       bfd_set_error (bfd_error_system_call);
 587     }
 588   return nwrote;
 589 }
 590
 591 /*
 592 INTERNAL_FUNCTION
 593         bfd_write_bigendian_4byte_int
 594
 595 SYNOPSIS
 596         void bfd_write_bigendian_4byte_int (bfd *, unsigned int);
 597
 598 DESCRIPTION
 599         Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
 600         endian order regardless of what else is going on.  This is useful in
 601         archives.
 602
 603 */
 604 void
 605 bfd_write_bigendian_4byte_int (abfd, i)
 606      bfd *abfd;
 607      unsigned int i;
 608 {
 609   bfd_byte buffer[4];
 610   bfd_putb32 ((bfd_vma) i, buffer);
 611   if (bfd_bwrite ((PTR) buffer, (bfd_size_type) 4, abfd) != 4)
 612     abort ();
 613 }
 614
 615 bfd_vma
 616 bfd_tell (abfd)
 617      bfd *abfd;
 618 {
 619   file_ptr ptr;
 620
 621   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 622     return abfd->where;
 623
 624   ptr = ftell (bfd_cache_lookup (abfd));
 625
 626   if (abfd->my_archive)
 627     ptr -= abfd->origin;
 628   abfd->where = ptr;
 629   return ptr;
 630 }
 631
 632 int
 633 bfd_flush (abfd)
 634      bfd *abfd;
 635 {
 636   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 637     return 0;
 638   return fflush (bfd_cache_lookup(abfd));
 639 }
 640
 641 /* Returns 0 for success, negative value for failure (in which case
 642    bfd_get_error can retrieve the error code).  */
 643 int
 644 bfd_stat (abfd, statbuf)
 645      bfd *abfd;
 646      struct stat *statbuf;
 647 {
 648   FILE *f;
 649   int result;
 650
 651   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 652     abort ();
 653
 654   f = bfd_cache_lookup (abfd);
 655   if (f == NULL)
 656     {
 657       bfd_set_error (bfd_error_system_call);
 658       return -1;
 659     }
 660   result = fstat (fileno (f), statbuf);
 661   if (result < 0)
 662     bfd_set_error (bfd_error_system_call);
 663   return result;
 664 }
 665
 666 /* Returns 0 for success, nonzero for failure (in which case bfd_get_error
 667    can retrieve the error code).  */
 668
 669 int
 670 bfd_seek (abfd, position, direction)
 671      bfd *abfd;
 672      file_ptr position;
 673      int direction;
 674 {
 675   int result;
 676   FILE *f;
 677   long file_position;
 678   /* For the time being, a BFD may not seek to it's end.  The problem
 679      is that we don't easily have a way to recognize the end of an
 680      element in an archive.  */
 681
 682   BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);
 683
 684   if (direction == SEEK_CUR && position == 0)
 685     return 0;
 686
 687   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 688     {
 689       struct bfd_in_memory *bim;
 690
 691       bim = (struct bfd_in_memory *) abfd->iostream;
 692
 693       if (direction == SEEK_SET)
 694         abfd->where = position;
 695       else
 696         abfd->where += position;
 697
 698       if (abfd->where > bim->size)
 699         {
 700           if ((abfd->direction == write_direction) ||
 701               (abfd->direction == both_direction))
 702             {
 703               bfd_size_type newsize, oldsize;
 704               oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
 705               bim->size = abfd->where;
 706               /* Round up to cut down on memory fragmentation */
 707               newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 708               if (newsize > oldsize)
 709                 {
 710                   bim->buffer = bfd_realloc (bim->buffer, newsize);
 711                   if (bim->buffer == 0)
 712                     {
 713                       bim->size = 0;
 714                       return -1;
 715                     }
 716                 }
 717             }
 718           else
 719             {
 720               abfd->where = bim->size;
 721               bfd_set_error (bfd_error_file_truncated);
 722               return -1;
 723             }
 724         }
 725       return 0;
 726     }
 727
 728   if (abfd->format != bfd_archive && abfd->my_archive == 0)
 729     {
 730 #if 0
 731       /* Explanation for this code: I'm only about 95+% sure that the above
 732          conditions are sufficient and that all i/o calls are properly
 733          adjusting the `where' field.  So this is sort of an `assert'
 734          that the `where' field is correct.  If we can go a while without
 735          tripping the abort, we can probably safely disable this code,
 736          so that the real optimizations happen.  */
 737       file_ptr where_am_i_now;
 738       where_am_i_now = ftell (bfd_cache_lookup (abfd));
 739       if (abfd->my_archive)
 740         where_am_i_now -= abfd->origin;
 741       if (where_am_i_now != abfd->where)
 742         abort ();
 743 #endif
 744       if (direction == SEEK_SET && (bfd_vma) position == abfd->where)
 745         return 0;
 746     }
 747   else
 748     {
 749       /* We need something smarter to optimize access to archives.
 750          Currently, anything inside an archive is read via the file
 751          handle for the archive.  Which means that a bfd_seek on one
 752          component affects the `current position' in the archive, as
 753          well as in any other component.
 754
 755          It might be sufficient to put a spike through the cache
 756          abstraction, and look to the archive for the file position,
 757          but I think we should try for something cleaner.
 758
 759          In the meantime, no optimization for archives.  */
 760     }
 761
 762   f = bfd_cache_lookup (abfd);
 763   file_position = position;
 764   if (direction == SEEK_SET && abfd->my_archive != NULL)
 765     file_position += abfd->origin;
 766
 767   result = fseek (f, file_position, direction);
 768   if (result != 0)
 769     {
 770       int hold_errno = errno;
 771
 772       /* Force redetermination of `where' field.  */
 773       bfd_tell (abfd);
 774
 775       /* An EINVAL error probably means that the file offset was
 776          absurd.  */
 777       if (hold_errno == EINVAL)
 778         bfd_set_error (bfd_error_file_truncated);
 779       else
 780         {
 781           bfd_set_error (bfd_error_system_call);
 782           errno = hold_errno;
 783         }
 784     }
 785   else
 786     {
 787       /* Adjust `where' field.  */
 788       if (direction == SEEK_SET)
 789         abfd->where = position;
 790       else
 791         abfd->where += position;
 792     }
 793   return result;
 794 }
 795 \f
 796 /** The do-it-yourself (byte) sex-change kit */
 797
 798 /* The middle letter e.g. get<b>short indicates Big or Little endian
 799    target machine.  It doesn't matter what the byte order of the host
 800    machine is; these routines work for either.  */
 801
 802 /* FIXME: Should these take a count argument?
 803    Answer (gnu@cygnus.com):  No, but perhaps they should be inline
 804                              functions in swap.h #ifdef __GNUC__.
 805                              Gprof them later and find out.  */
 806
 807 /*
 808 FUNCTION
 809         bfd_put_size
 810 FUNCTION
 811         bfd_get_size
 812
 813 DESCRIPTION
 814         These macros as used for reading and writing raw data in
 815         sections; each access (except for bytes) is vectored through
 816         the target format of the BFD and mangled accordingly. The
 817         mangling performs any necessary endian translations and
 818         removes alignment restrictions.  Note that types accepted and
 819         returned by these macros are identical so they can be swapped
 820         around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
 821         to either <<bfd_get_32>> or <<bfd_get_64>>.
 822
 823         In the put routines, @var{val} must be a <<bfd_vma>>.  If we are on a
 824         system without prototypes, the caller is responsible for making
 825         sure that is true, with a cast if necessary.  We don't cast
 826         them in the macro definitions because that would prevent <<lint>>
 827         or <<gcc -Wall>> from detecting sins such as passing a pointer.
 828         To detect calling these with less than a <<bfd_vma>>, use
 829         <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
 830
 831 .
 832 .{* Byte swapping macros for user section data.  *}
 833 .
 834 .#define bfd_put_8(abfd, val, ptr) \
 835 .                ((void) (*((unsigned char *) (ptr)) = (unsigned char) (val)))
 836 .#define bfd_put_signed_8 \
 837 .               bfd_put_8
 838 .#define bfd_get_8(abfd, ptr) \
 839 .                (*(unsigned char *) (ptr) & 0xff)
 840 .#define bfd_get_signed_8(abfd, ptr) \
 841 .               (((*(unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)
 842 .
 843 .#define bfd_put_16(abfd, val, ptr) \
 844 .                BFD_SEND(abfd, bfd_putx16, ((val),(ptr)))
 845 .#define bfd_put_signed_16 \
 846 .                bfd_put_16
 847 .#define bfd_get_16(abfd, ptr) \
 848 .                BFD_SEND(abfd, bfd_getx16, (ptr))
 849 .#define bfd_get_signed_16(abfd, ptr) \
 850 .                BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
 851 .
 852 .#define bfd_put_32(abfd, val, ptr) \
 853 .                BFD_SEND(abfd, bfd_putx32, ((val),(ptr)))
 854 .#define bfd_put_signed_32 \
 855 .                bfd_put_32
 856 .#define bfd_get_32(abfd, ptr) \
 857 .                BFD_SEND(abfd, bfd_getx32, (ptr))
 858 .#define bfd_get_signed_32(abfd, ptr) \
 859 .                BFD_SEND(abfd, bfd_getx_signed_32, (ptr))
 860 .
 861 .#define bfd_put_64(abfd, val, ptr) \
 862 .                BFD_SEND(abfd, bfd_putx64, ((val), (ptr)))
 863 .#define bfd_put_signed_64 \
 864 .                bfd_put_64
 865 .#define bfd_get_64(abfd, ptr) \
 866 .                BFD_SEND(abfd, bfd_getx64, (ptr))
 867 .#define bfd_get_signed_64(abfd, ptr) \
 868 .                BFD_SEND(abfd, bfd_getx_signed_64, (ptr))
 869 .
 870 .#define bfd_get(bits, abfd, ptr)                               \
 871 .                ( (bits) ==  8 ? (bfd_vma) bfd_get_8 (abfd, ptr)       \
 872 .                : (bits) == 16 ? bfd_get_16 (abfd, ptr)        \
 873 .                : (bits) == 32 ? bfd_get_32 (abfd, ptr)        \
 874 .                : (bits) == 64 ? bfd_get_64 (abfd, ptr)        \
 875 .                : (abort (), (bfd_vma) - 1))
 876 .
 877 .#define bfd_put(bits, abfd, val, ptr)                          \
 878 .                ( (bits) ==  8 ? bfd_put_8  (abfd, val, ptr)   \
 879 .                : (bits) == 16 ? bfd_put_16 (abfd, val, ptr)   \
 880 .                : (bits) == 32 ? bfd_put_32 (abfd, val, ptr)   \
 881 .                : (bits) == 64 ? bfd_put_64 (abfd, val, ptr)   \
 882 .                : (abort (), (void) 0))
 883 .
 884 */
 885
 886 /*
 887 FUNCTION
 888         bfd_h_put_size
 889         bfd_h_get_size
 890
 891 DESCRIPTION
 892         These macros have the same function as their <<bfd_get_x>>
 893         brethren, except that they are used for removing information
 894         for the header records of object files. Believe it or not,
 895         some object files keep their header records in big endian
 896         order and their data in little endian order.
 897 .
 898 .{* Byte swapping macros for file header data.  *}
 899 .
 900 .#define bfd_h_put_8(abfd, val, ptr) \
 901 .  bfd_put_8 (abfd, val, ptr)
 902 .#define bfd_h_put_signed_8(abfd, val, ptr) \
 903 .  bfd_put_8 (abfd, val, ptr)
 904 .#define bfd_h_get_8(abfd, ptr) \
 905 .  bfd_get_8 (abfd, ptr)
 906 .#define bfd_h_get_signed_8(abfd, ptr) \
 907 .  bfd_get_signed_8 (abfd, ptr)
 908 .
 909 .#define bfd_h_put_16(abfd, val, ptr) \
 910 .  BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
 911 .#define bfd_h_put_signed_16 \
 912 .  bfd_h_put_16
 913 .#define bfd_h_get_16(abfd, ptr) \
 914 .  BFD_SEND (abfd, bfd_h_getx16, (ptr))
 915 .#define bfd_h_get_signed_16(abfd, ptr) \
 916 .  BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
 917 .
 918 .#define bfd_h_put_32(abfd, val, ptr) \
 919 .  BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
 920 .#define bfd_h_put_signed_32 \
 921 .  bfd_h_put_32
 922 .#define bfd_h_get_32(abfd, ptr) \
 923 .  BFD_SEND (abfd, bfd_h_getx32, (ptr))
 924 .#define bfd_h_get_signed_32(abfd, ptr) \
 925 .  BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
 926 .
 927 .#define bfd_h_put_64(abfd, val, ptr) \
 928 .  BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
 929 .#define bfd_h_put_signed_64 \
 930 .  bfd_h_put_64
 931 .#define bfd_h_get_64(abfd, ptr) \
 932 .  BFD_SEND (abfd, bfd_h_getx64, (ptr))
 933 .#define bfd_h_get_signed_64(abfd, ptr) \
 934 .  BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
 935 .
 936 .{* Refinements on the above, which should eventually go away.  Save
 937 .   cluttering the source with (bfd_vma) and (bfd_byte *) casts.  *}
 938 .
 939 .#define H_PUT_64(abfd, val, where) \
 940 .  bfd_h_put_64 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
 941 .
 942 .#define H_PUT_32(abfd, val, where) \
 943 .  bfd_h_put_32 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
 944 .
 945 .#define H_PUT_16(abfd, val, where) \
 946 .  bfd_h_put_16 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
 947 .
 948 .#define H_PUT_8 bfd_h_put_8
 949 .
 950 .#define H_PUT_S64(abfd, val, where) \
 951 .  bfd_h_put_signed_64 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
 952 .
 953 .#define H_PUT_S32(abfd, val, where) \
 954 .  bfd_h_put_signed_32 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
 955 .
 956 .#define H_PUT_S16(abfd, val, where) \
 957 .  bfd_h_put_signed_16 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
 958 .
 959 .#define H_PUT_S8 bfd_h_put_signed_8
 960 .
 961 .#define H_GET_64(abfd, where) \
 962 .  bfd_h_get_64 ((abfd), (bfd_byte *) (where))
 963 .
 964 .#define H_GET_32(abfd, where) \
 965 .  bfd_h_get_32 ((abfd), (bfd_byte *) (where))
 966 .
 967 .#define H_GET_16(abfd, where) \
 968 .  bfd_h_get_16 ((abfd), (bfd_byte *) (where))
 969 .
 970 .#define H_GET_8 bfd_h_get_8
 971 .
 972 .#define H_GET_S64(abfd, where) \
 973 .  bfd_h_get_signed_64 ((abfd), (bfd_byte *) (where))
 974 .
 975 .#define H_GET_S32(abfd, where) \
 976 .  bfd_h_get_signed_32 ((abfd), (bfd_byte *) (where))
 977 .
 978 .#define H_GET_S16(abfd, where) \
 979 .  bfd_h_get_signed_16 ((abfd), (bfd_byte *) (where))
 980 .
 981 .#define H_GET_S8 bfd_h_get_signed_8
 982 .
 983 .*/
 984
 985 /* Sign extension to bfd_signed_vma.  */
 986 #define COERCE16(x) (((bfd_signed_vma) (x) ^ 0x8000) - 0x8000)
 987 #define COERCE32(x) \
 988   ((bfd_signed_vma) (long) (((unsigned long) (x) ^ 0x80000000) - 0x80000000))
 989 #define EIGHT_GAZILLION (((BFD_HOST_64_BIT)0x80000000) << 32)
 990 #define COERCE64(x) \
 991   (((bfd_signed_vma) (x) ^ EIGHT_GAZILLION) - EIGHT_GAZILLION)
 992
 993 bfd_vma
 994 bfd_getb16 (addr)
 995      register const bfd_byte *addr;
 996 {
 997   return (addr[0] << 8) | addr[1];
 998 }
 999
1000 bfd_vma
1001 bfd_getl16 (addr)
1002      register const bfd_byte *addr;
1003 {
1004   return (addr[1] << 8) | addr[0];
1005 }
1006
1007 bfd_signed_vma
1008 bfd_getb_signed_16 (addr)
1009      register const bfd_byte *addr;
1010 {
1011   return COERCE16((addr[0] << 8) | addr[1]);
1012 }
1013
1014 bfd_signed_vma
1015 bfd_getl_signed_16 (addr)
1016      register const bfd_byte *addr;
1017 {
1018   return COERCE16((addr[1] << 8) | addr[0]);
1019 }
1020
1021 void
1022 bfd_putb16 (data, addr)
1023      bfd_vma data;
1024      register bfd_byte *addr;
1025 {
1026   addr[0] = (bfd_byte) (data >> 8);
1027   addr[1] = (bfd_byte) data;
1028 }
1029
1030 void
1031 bfd_putl16 (data, addr)
1032      bfd_vma data;
1033      register bfd_byte *addr;
1034 {
1035   addr[0] = (bfd_byte) data;
1036   addr[1] = (bfd_byte) (data >> 8);
1037 }
1038
1039 bfd_vma
1040 bfd_getb32 (addr)
1041      register const bfd_byte *addr;
1042 {
1043   unsigned long v;
1044
1045   v = (unsigned long) addr[0] << 24;
1046   v |= (unsigned long) addr[1] << 16;
1047   v |= (unsigned long) addr[2] << 8;
1048   v |= (unsigned long) addr[3];
1049   return (bfd_vma) v;
1050 }
1051
1052 bfd_vma
1053 bfd_getl32 (addr)
1054      register const bfd_byte *addr;
1055 {
1056   unsigned long v;
1057
1058   v = (unsigned long) addr[0];
1059   v |= (unsigned long) addr[1] << 8;
1060   v |= (unsigned long) addr[2] << 16;
1061   v |= (unsigned long) addr[3] << 24;
1062   return (bfd_vma) v;
1063 }
1064
1065 bfd_signed_vma
1066 bfd_getb_signed_32 (addr)
1067      register const bfd_byte *addr;
1068 {
1069   unsigned long v;
1070
1071   v = (unsigned long) addr[0] << 24;
1072   v |= (unsigned long) addr[1] << 16;
1073   v |= (unsigned long) addr[2] << 8;
1074   v |= (unsigned long) addr[3];
1075   return COERCE32 (v);
1076 }
1077
1078 bfd_signed_vma
1079 bfd_getl_signed_32 (addr)
1080      register const bfd_byte *addr;
1081 {
1082   unsigned long v;
1083
1084   v = (unsigned long) addr[0];
1085   v |= (unsigned long) addr[1] << 8;
1086   v |= (unsigned long) addr[2] << 16;
1087   v |= (unsigned long) addr[3] << 24;
1088   return COERCE32 (v);
1089 }
1090
1091 bfd_vma
1092 bfd_getb64 (addr)
1093      register const bfd_byte *addr ATTRIBUTE_UNUSED;
1094 {
1095 #ifdef BFD64
1096   bfd_vma low, high;
1097
1098   high= ((((((((addr[0]) << 8) |
1099               addr[1]) << 8) |
1100             addr[2]) << 8) |
1101           addr[3]) );
1102
1103   low = (((((((((bfd_vma)addr[4]) << 8) |
1104               addr[5]) << 8) |
1105             addr[6]) << 8) |
1106           addr[7]));
1107
1108   return high << 32 | low;
1109 #else
1110   BFD_FAIL();
1111   return 0;
1112 #endif
1113 }
1114
1115 bfd_vma
1116 bfd_getl64 (addr)
1117      register const bfd_byte *addr ATTRIBUTE_UNUSED;
1118 {
1119 #ifdef BFD64
1120   bfd_vma low, high;
1121   high= (((((((addr[7] << 8) |
1122               addr[6]) << 8) |
1123             addr[5]) << 8) |
1124           addr[4]));
1125
1126   low = ((((((((bfd_vma)addr[3] << 8) |
1127               addr[2]) << 8) |
1128             addr[1]) << 8) |
1129           addr[0]) );
1130
1131   return high << 32 | low;
1132 #else
1133   BFD_FAIL();
1134   return 0;
1135 #endif
1136
1137 }
1138
1139 bfd_signed_vma
1140 bfd_getb_signed_64 (addr)
1141      register const bfd_byte *addr ATTRIBUTE_UNUSED;
1142 {
1143 #ifdef BFD64
1144   bfd_vma low, high;
1145
1146   high= ((((((((addr[0]) << 8) |
1147               addr[1]) << 8) |
1148             addr[2]) << 8) |
1149           addr[3]) );
1150
1151   low = (((((((((bfd_vma)addr[4]) << 8) |
1152               addr[5]) << 8) |
1153             addr[6]) << 8) |
1154           addr[7]));
1155
1156   return COERCE64(high << 32 | low);
1157 #else
1158   BFD_FAIL();
1159   return 0;
1160 #endif
1161 }
1162
1163 bfd_signed_vma
1164 bfd_getl_signed_64 (addr)
1165      register const bfd_byte *addr ATTRIBUTE_UNUSED;
1166 {
1167 #ifdef BFD64
1168   bfd_vma low, high;
1169   high= (((((((addr[7] << 8) |
1170               addr[6]) << 8) |
1171             addr[5]) << 8) |
1172           addr[4]));
1173
1174   low = ((((((((bfd_vma)addr[3] << 8) |
1175               addr[2]) << 8) |
1176             addr[1]) << 8) |
1177           addr[0]) );
1178
1179   return COERCE64(high << 32 | low);
1180 #else
1181   BFD_FAIL();
1182   return 0;
1183 #endif
1184 }
1185
1186 void
1187 bfd_putb32 (data, addr)
1188      bfd_vma data;
1189      register bfd_byte *addr;
1190 {
1191         addr[0] = (bfd_byte) (data >> 24);
1192         addr[1] = (bfd_byte) (data >> 16);
1193         addr[2] = (bfd_byte) (data >>  8);
1194         addr[3] = (bfd_byte) data;
1195 }
1196
1197 void
1198 bfd_putl32 (data, addr)
1199      bfd_vma data;
1200      register bfd_byte *addr;
1201 {
1202         addr[0] = (bfd_byte) data;
1203         addr[1] = (bfd_byte) (data >>  8);
1204         addr[2] = (bfd_byte) (data >> 16);
1205         addr[3] = (bfd_byte) (data >> 24);
1206 }
1207
1208 void
1209 bfd_putb64 (data, addr)
1210      bfd_vma data ATTRIBUTE_UNUSED;
1211      register bfd_byte *addr ATTRIBUTE_UNUSED;
1212 {
1213 #ifdef BFD64
1214   addr[0] = (bfd_byte) (data >> (7*8));
1215   addr[1] = (bfd_byte) (data >> (6*8));
1216   addr[2] = (bfd_byte) (data >> (5*8));
1217   addr[3] = (bfd_byte) (data >> (4*8));
1218   addr[4] = (bfd_byte) (data >> (3*8));
1219   addr[5] = (bfd_byte) (data >> (2*8));
1220   addr[6] = (bfd_byte) (data >> (1*8));
1221   addr[7] = (bfd_byte) (data >> (0*8));
1222 #else
1223   BFD_FAIL();
1224 #endif
1225 }
1226
1227 void
1228 bfd_putl64 (data, addr)
1229      bfd_vma data ATTRIBUTE_UNUSED;
1230      register bfd_byte *addr ATTRIBUTE_UNUSED;
1231 {
1232 #ifdef BFD64
1233   addr[7] = (bfd_byte) (data >> (7*8));
1234   addr[6] = (bfd_byte) (data >> (6*8));
1235   addr[5] = (bfd_byte) (data >> (5*8));
1236   addr[4] = (bfd_byte) (data >> (4*8));
1237   addr[3] = (bfd_byte) (data >> (3*8));
1238   addr[2] = (bfd_byte) (data >> (2*8));
1239   addr[1] = (bfd_byte) (data >> (1*8));
1240   addr[0] = (bfd_byte) (data >> (0*8));
1241 #else
1242   BFD_FAIL();
1243 #endif
1244 }
1245
1246 void
1247 bfd_put_bits (data, addr, bits, big_p)
1248      bfd_vma data;
1249      bfd_byte *addr;
1250      int bits;
1251      boolean big_p;
1252 {
1253   int i;
1254   int bytes;
1255
1256   if (bits % 8 != 0)
1257     abort ();
1258
1259   bytes = bits / 8;
1260   for (i = 0; i < bytes; i++)
1261     {
1262       int index = big_p ? bytes - i - 1 : i;
1263
1264       addr[index] = (bfd_byte) data;
1265       data >>= 8;
1266     }
1267 }
1268
1269 bfd_vma
1270 bfd_get_bits (addr, bits, big_p)
1271      bfd_byte *addr;
1272      int bits;
1273      boolean big_p;
1274 {
1275   bfd_vma data;
1276   int i;
1277   int bytes;
1278
1279   if (bits % 8 != 0)
1280     abort ();
1281
1282   data = 0;
1283   bytes = bits / 8;
1284   for (i = 0; i < bytes; i++)
1285     {
1286       int index = big_p ? i : bytes - i - 1;
1287
1288       data = (data << 8) | addr[index];
1289     }
1290
1291   return data;
1292 }
1293 \f
1294 /* Default implementation */
1295
1296 boolean
1297 _bfd_generic_get_section_contents (abfd, section, location, offset, count)
1298      bfd *abfd;
1299      sec_ptr section;
1300      PTR location;
1301      file_ptr offset;
1302      bfd_size_type count;
1303 {
1304   if (count == 0)
1305     return true;
1306
1307   if (offset + count > section->_raw_size)
1308     {
1309       bfd_set_error (bfd_error_invalid_operation);
1310       return false;
1311     }
1312
1313   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1314       || bfd_bread (location, count, abfd) != count)
1315     return false;
1316
1317   return true;
1318 }
1319
1320 boolean
1321 _bfd_generic_get_section_contents_in_window (abfd, section, w, offset, count)
1322      bfd *abfd ATTRIBUTE_UNUSED;
1323      sec_ptr section ATTRIBUTE_UNUSED;
1324      bfd_window *w ATTRIBUTE_UNUSED;
1325      file_ptr offset ATTRIBUTE_UNUSED;
1326      bfd_size_type count ATTRIBUTE_UNUSED;
1327 {
1328 #ifdef USE_MMAP
1329   if (count == 0)
1330     return true;
1331   if (abfd->xvec->_bfd_get_section_contents != _bfd_generic_get_section_contents)
1332     {
1333       /* We don't know what changes the bfd's get_section_contents
1334          method may have to make.  So punt trying to map the file
1335          window, and let get_section_contents do its thing.  */
1336       /* @@ FIXME : If the internal window has a refcount of 1 and was
1337          allocated with malloc instead of mmap, just reuse it.  */
1338       bfd_free_window (w);
1339       w->i = ((bfd_window_internal *)
1340               bfd_zmalloc ((bfd_size_type) sizeof (bfd_window_internal)));
1341       if (w->i == NULL)
1342         return false;
1343       w->i->data = (PTR) bfd_malloc (count);
1344       if (w->i->data == NULL)
1345         {
1346           free (w->i);
1347           w->i = NULL;
1348           return false;
1349         }
1350       w->i->mapped = 0;
1351       w->i->refcount = 1;
1352       w->size = w->i->size = count;
1353       w->data = w->i->data;
1354       return bfd_get_section_contents (abfd, section, w->data, offset, count);
1355     }
1356   if (offset + count > section->_raw_size
1357       || (bfd_get_file_window (abfd, section->filepos + offset, count, w, true)
1358           == false))
1359     return false;
1360   return true;
1361 #else
1362   abort ();
1363 #endif
1364 }
1365
1366 /* This generic function can only be used in implementations where creating
1367    NEW sections is disallowed.  It is useful in patching existing sections
1368    in read-write files, though.  See other set_section_contents functions
1369    to see why it doesn't work for new sections.  */
1370 boolean
1371 _bfd_generic_set_section_contents (abfd, section, location, offset, count)
1372      bfd *abfd;
1373      sec_ptr section;
1374      PTR location;
1375      file_ptr offset;
1376      bfd_size_type count;
1377 {
1378   if (count == 0)
1379     return true;
1380
1381   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1382       || bfd_bwrite (location, count, abfd) != count)
1383     return false;
1384
1385   return true;
1386 }
1387
1388 /*
1389 INTERNAL_FUNCTION
1390         bfd_log2
1391
1392 SYNOPSIS
1393         unsigned int bfd_log2 (bfd_vma x);
1394
1395 DESCRIPTION
1396         Return the log base 2 of the value supplied, rounded up.  E.g., an
1397         @var{x} of 1025 returns 11.  A @var{x} of 0 returns 0.
1398 */
1399
1400 unsigned int
1401 bfd_log2 (x)
1402      bfd_vma x;
1403 {
1404   unsigned int result = 0;
1405
1406   while ((x = (x >> 1)) != 0)
1407     ++result;
1408   return result;
1409 }
1410
1411 boolean
1412 bfd_generic_is_local_label_name (abfd, name)
1413      bfd *abfd;
1414      const char *name;
1415 {
1416   char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
1417
1418   return (name[0] == locals_prefix);
1419 }
1420
1421 /*  Can be used from / for bfd_merge_private_bfd_data to check that
1422     endianness matches between input and output file.  Returns
1423     true for a match, otherwise returns false and emits an error.  */
1424 boolean
1425 _bfd_generic_verify_endian_match (ibfd, obfd)
1426      bfd *ibfd;
1427      bfd *obfd;
1428 {
1429   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1430       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1431       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1432     {
1433       const char *msg;
1434
1435       if (bfd_big_endian (ibfd))
1436         msg = _("%s: compiled for a big endian system and target is little endian");
1437       else
1438         msg = _("%s: compiled for a little endian system and target is big endian");
1439
1440       (*_bfd_error_handler) (msg, bfd_archive_filename (ibfd));
1441
1442       bfd_set_error (bfd_error_wrong_format);
1443       return false;
1444     }
1445
1446   return true;
1447 }
1448
1449 /* Give a warning at runtime if someone compiles code which calls
1450    old routines.  */
1451
1452 void
1453 warn_deprecated (what, file, line, func)
1454      const char *what;
1455      const char *file;
1456      int line;
1457      const char *func;
1458 {
1459   /* Poor man's tracking of functions we've already warned about.  */
1460   static size_t mask = 0;
1461
1462   if (~(size_t) func & ~mask)
1463     {
1464       /* Note: seperate sentances in order to allow
1465          for translation into other languages.  */
1466       if (func)
1467         fprintf (stderr, _("Deprecated %s called at %s line %d in %s\n"),
1468                  what, file, line, func);
1469       else
1470         fprintf (stderr, _("Deprecated %s called\n"), what);
1471       mask |= ~(size_t) func;
1472     }
1473 }