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
   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       if (nwrote >= 0)
 585         errno = ENOSPC;
 586 #endif
 587       bfd_set_error (bfd_error_system_call);
 588     }
 589   return nwrote;
 590 }
 591
 592 /*
 593 INTERNAL_FUNCTION
 594         bfd_write_bigendian_4byte_int
 595
 596 SYNOPSIS
 597         void bfd_write_bigendian_4byte_int (bfd *, unsigned int);
 598
 599 DESCRIPTION
 600         Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
 601         endian order regardless of what else is going on.  This is useful in
 602         archives.
 603
 604 */
 605 void
 606 bfd_write_bigendian_4byte_int (abfd, i)
 607      bfd *abfd;
 608      unsigned int i;
 609 {
 610   bfd_byte buffer[4];
 611   bfd_putb32 ((bfd_vma) i, buffer);
 612   if (bfd_bwrite ((PTR) buffer, (bfd_size_type) 4, abfd) != 4)
 613     abort ();
 614 }
 615
 616 bfd_vma
 617 bfd_tell (abfd)
 618      bfd *abfd;
 619 {
 620   file_ptr ptr;
 621
 622   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 623     return abfd->where;
 624
 625   ptr = ftell (bfd_cache_lookup (abfd));
 626
 627   if (abfd->my_archive)
 628     ptr -= abfd->origin;
 629   abfd->where = ptr;
 630   return ptr;
 631 }
 632
 633 int
 634 bfd_flush (abfd)
 635      bfd *abfd;
 636 {
 637   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 638     return 0;
 639   return fflush (bfd_cache_lookup(abfd));
 640 }
 641
 642 /* Returns 0 for success, negative value for failure (in which case
 643    bfd_get_error can retrieve the error code).  */
 644 int
 645 bfd_stat (abfd, statbuf)
 646      bfd *abfd;
 647      struct stat *statbuf;
 648 {
 649   FILE *f;
 650   int result;
 651
 652   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 653     abort ();
 654
 655   f = bfd_cache_lookup (abfd);
 656   if (f == NULL)
 657     {
 658       bfd_set_error (bfd_error_system_call);
 659       return -1;
 660     }
 661   result = fstat (fileno (f), statbuf);
 662   if (result < 0)
 663     bfd_set_error (bfd_error_system_call);
 664   return result;
 665 }
 666
 667 /* Returns 0 for success, nonzero for failure (in which case bfd_get_error
 668    can retrieve the error code).  */
 669
 670 int
 671 bfd_seek (abfd, position, direction)
 672      bfd *abfd;
 673      file_ptr position;
 674      int direction;
 675 {
 676   int result;
 677   FILE *f;
 678   long file_position;
 679   /* For the time being, a BFD may not seek to it's end.  The problem
 680      is that we don't easily have a way to recognize the end of an
 681      element in an archive.  */
 682
 683   BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);
 684
 685   if (direction == SEEK_CUR && position == 0)
 686     return 0;
 687
 688   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 689     {
 690       struct bfd_in_memory *bim;
 691
 692       bim = (struct bfd_in_memory *) abfd->iostream;
 693
 694       if (direction == SEEK_SET)
 695         abfd->where = position;
 696       else
 697         abfd->where += position;
 698
 699       if (abfd->where > bim->size)
 700         {
 701           if ((abfd->direction == write_direction) ||
 702               (abfd->direction == both_direction))
 703             {
 704               bfd_size_type newsize, oldsize;
 705               oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
 706               bim->size = abfd->where;
 707               /* Round up to cut down on memory fragmentation */
 708               newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 709               if (newsize > oldsize)
 710                 {
 711                   bim->buffer = bfd_realloc (bim->buffer, newsize);
 712                   if (bim->buffer == 0)
 713                     {
 714                       bim->size = 0;
 715                       return -1;
 716                     }
 717                 }
 718             }
 719           else
 720             {
 721               abfd->where = bim->size;
 722               bfd_set_error (bfd_error_file_truncated);
 723               return -1;
 724             }
 725         }
 726       return 0;
 727     }
 728
 729   if (abfd->format != bfd_archive && abfd->my_archive == 0)
 730     {
 731 #if 0
 732       /* Explanation for this code: I'm only about 95+% sure that the above
 733          conditions are sufficient and that all i/o calls are properly
 734          adjusting the `where' field.  So this is sort of an `assert'
 735          that the `where' field is correct.  If we can go a while without
 736          tripping the abort, we can probably safely disable this code,
 737          so that the real optimizations happen.  */
 738       file_ptr where_am_i_now;
 739       where_am_i_now = ftell (bfd_cache_lookup (abfd));
 740       if (abfd->my_archive)
 741         where_am_i_now -= abfd->origin;
 742       if (where_am_i_now != abfd->where)
 743         abort ();
 744 #endif
 745       if (direction == SEEK_SET && (bfd_vma) position == abfd->where)
 746         return 0;
 747     }
 748   else
 749     {
 750       /* We need something smarter to optimize access to archives.
 751          Currently, anything inside an archive is read via the file
 752          handle for the archive.  Which means that a bfd_seek on one
 753          component affects the `current position' in the archive, as
 754          well as in any other component.
 755
 756          It might be sufficient to put a spike through the cache
 757          abstraction, and look to the archive for the file position,
 758          but I think we should try for something cleaner.
 759
 760          In the meantime, no optimization for archives.  */
 761     }
 762
 763   f = bfd_cache_lookup (abfd);
 764   file_position = position;
 765   if (direction == SEEK_SET && abfd->my_archive != NULL)
 766     file_position += abfd->origin;
 767
 768   result = fseek (f, file_position, direction);
 769   if (result != 0)
 770     {
 771       int hold_errno = errno;
 772
 773       /* Force redetermination of `where' field.  */
 774       bfd_tell (abfd);
 775
 776       /* An EINVAL error probably means that the file offset was
 777          absurd.  */
 778       if (hold_errno == EINVAL)
 779         bfd_set_error (bfd_error_file_truncated);
 780       else
 781         {
 782           bfd_set_error (bfd_error_system_call);
 783           errno = hold_errno;
 784         }
 785     }
 786   else
 787     {
 788       /* Adjust `where' field.  */
 789       if (direction == SEEK_SET)
 790         abfd->where = position;
 791       else
 792         abfd->where += position;
 793     }
 794   return result;
 795 }
 796 \f
 797 /** The do-it-yourself (byte) sex-change kit */
 798
 799 /* The middle letter e.g. get<b>short indicates Big or Little endian
 800    target machine.  It doesn't matter what the byte order of the host
 801    machine is; these routines work for either.  */
 802
 803 /* FIXME: Should these take a count argument?
 804    Answer (gnu@cygnus.com):  No, but perhaps they should be inline
 805                              functions in swap.h #ifdef __GNUC__.
 806                              Gprof them later and find out.  */
 807
 808 /*
 809 FUNCTION
 810         bfd_put_size
 811 FUNCTION
 812         bfd_get_size
 813
 814 DESCRIPTION
 815         These macros as used for reading and writing raw data in
 816         sections; each access (except for bytes) is vectored through
 817         the target format of the BFD and mangled accordingly. The
 818         mangling performs any necessary endian translations and
 819         removes alignment restrictions.  Note that types accepted and
 820         returned by these macros are identical so they can be swapped
 821         around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
 822         to either <<bfd_get_32>> or <<bfd_get_64>>.
 823
 824         In the put routines, @var{val} must be a <<bfd_vma>>.  If we are on a
 825         system without prototypes, the caller is responsible for making
 826         sure that is true, with a cast if necessary.  We don't cast
 827         them in the macro definitions because that would prevent <<lint>>
 828         or <<gcc -Wall>> from detecting sins such as passing a pointer.
 829         To detect calling these with less than a <<bfd_vma>>, use
 830         <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
 831
 832 .
 833 .{* Byte swapping macros for user section data.  *}
 834 .
 835 .#define bfd_put_8(abfd, val, ptr) \
 836 .                ((void) (*((unsigned char *) (ptr)) = (unsigned char) (val)))
 837 .#define bfd_put_signed_8 \
 838 .               bfd_put_8
 839 .#define bfd_get_8(abfd, ptr) \
 840 .                (*(unsigned char *) (ptr) & 0xff)
 841 .#define bfd_get_signed_8(abfd, ptr) \
 842 .               (((*(unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)
 843 .
 844 .#define bfd_put_16(abfd, val, ptr) \
 845 .                BFD_SEND(abfd, bfd_putx16, ((val),(ptr)))
 846 .#define bfd_put_signed_16 \
 847 .                bfd_put_16
 848 .#define bfd_get_16(abfd, ptr) \
 849 .                BFD_SEND(abfd, bfd_getx16, (ptr))
 850 .#define bfd_get_signed_16(abfd, ptr) \
 851 .                BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
 852 .
 853 .#define bfd_put_32(abfd, val, ptr) \
 854 .                BFD_SEND(abfd, bfd_putx32, ((val),(ptr)))
 855 .#define bfd_put_signed_32 \
 856 .                bfd_put_32
 857 .#define bfd_get_32(abfd, ptr) \
 858 .                BFD_SEND(abfd, bfd_getx32, (ptr))
 859 .#define bfd_get_signed_32(abfd, ptr) \
 860 .                BFD_SEND(abfd, bfd_getx_signed_32, (ptr))
 861 .
 862 .#define bfd_put_64(abfd, val, ptr) \
 863 .                BFD_SEND(abfd, bfd_putx64, ((val), (ptr)))
 864 .#define bfd_put_signed_64 \
 865 .                bfd_put_64
 866 .#define bfd_get_64(abfd, ptr) \
 867 .                BFD_SEND(abfd, bfd_getx64, (ptr))
 868 .#define bfd_get_signed_64(abfd, ptr) \
 869 .                BFD_SEND(abfd, bfd_getx_signed_64, (ptr))
 870 .
 871 .#define bfd_get(bits, abfd, ptr)                               \
 872 .                ((bits) == 8 ? bfd_get_8 (abfd, ptr)           \
 873 .                : (bits) == 16 ? bfd_get_16 (abfd, ptr)        \
 874 .                : (bits) == 32 ? bfd_get_32 (abfd, ptr)        \
 875 .                : (bits) == 64 ? bfd_get_64 (abfd, ptr)        \
 876 .                : (abort (), (bfd_vma) - 1))
 877 .
 878 .#define bfd_put(bits, abfd, val, ptr)                          \
 879 .                ((bits) == 8 ? bfd_put_8 (abfd, val, ptr)      \
 880 .                : (bits) == 16 ? bfd_put_16 (abfd, val, ptr)   \
 881 .                : (bits) == 32 ? bfd_put_32 (abfd, val, ptr)   \
 882 .                : (bits) == 64 ? bfd_put_64 (abfd, val, ptr)   \
 883 .                : (abort (), (void) 0))
 884 .
 885 */
 886
 887 /*
 888 FUNCTION
 889         bfd_h_put_size
 890         bfd_h_get_size
 891
 892 DESCRIPTION
 893         These macros have the same function as their <<bfd_get_x>>
 894         brethren, except that they are used for removing information
 895         for the header records of object files. Believe it or not,
 896         some object files keep their header records in big endian
 897         order and their data in little endian order.
 898 .
 899 .{* Byte swapping macros for file header data.  *}
 900 .
 901 .#define bfd_h_put_8(abfd, val, ptr) \
 902 .  bfd_put_8 (abfd, val, ptr)
 903 .#define bfd_h_put_signed_8(abfd, val, ptr) \
 904 .  bfd_put_8 (abfd, val, ptr)
 905 .#define bfd_h_get_8(abfd, ptr) \
 906 .  bfd_get_8 (abfd, ptr)
 907 .#define bfd_h_get_signed_8(abfd, ptr) \
 908 .  bfd_get_signed_8 (abfd, ptr)
 909 .
 910 .#define bfd_h_put_16(abfd, val, ptr) \
 911 .  BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
 912 .#define bfd_h_put_signed_16 \
 913 .  bfd_h_put_16
 914 .#define bfd_h_get_16(abfd, ptr) \
 915 .  BFD_SEND (abfd, bfd_h_getx16, (ptr))
 916 .#define bfd_h_get_signed_16(abfd, ptr) \
 917 .  BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
 918 .
 919 .#define bfd_h_put_32(abfd, val, ptr) \
 920 .  BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
 921 .#define bfd_h_put_signed_32 \
 922 .  bfd_h_put_32
 923 .#define bfd_h_get_32(abfd, ptr) \
 924 .  BFD_SEND (abfd, bfd_h_getx32, (ptr))
 925 .#define bfd_h_get_signed_32(abfd, ptr) \
 926 .  BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
 927 .
 928 .#define bfd_h_put_64(abfd, val, ptr) \
 929 .  BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
 930 .#define bfd_h_put_signed_64 \
 931 .  bfd_h_put_64
 932 .#define bfd_h_get_64(abfd, ptr) \
 933 .  BFD_SEND (abfd, bfd_h_getx64, (ptr))
 934 .#define bfd_h_get_signed_64(abfd, ptr) \
 935 .  BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
 936 .
 937 .{* Refinements on the above, which should eventually go away.  Save
 938 .   cluttering the source with (bfd_vma) and (bfd_byte *) casts.  *}
 939 .
 940 .#define H_PUT_64(abfd, val, where) \
 941 .  bfd_h_put_64 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
 942 .
 943 .#define H_PUT_32(abfd, val, where) \
 944 .  bfd_h_put_32 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
 945 .
 946 .#define H_PUT_16(abfd, val, where) \
 947 .  bfd_h_put_16 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
 948 .
 949 .#define H_PUT_8 bfd_h_put_8
 950 .
 951 .#define H_PUT_S64(abfd, val, where) \
 952 .  bfd_h_put_signed_64 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
 953 .
 954 .#define H_PUT_S32(abfd, val, where) \
 955 .  bfd_h_put_signed_32 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
 956 .
 957 .#define H_PUT_S16(abfd, val, where) \
 958 .  bfd_h_put_signed_16 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
 959 .
 960 .#define H_PUT_S8 bfd_h_put_signed_8
 961 .
 962 .#define H_GET_64(abfd, where) \
 963 .  bfd_h_get_64 ((abfd), (bfd_byte *) (where))
 964 .
 965 .#define H_GET_32(abfd, where) \
 966 .  bfd_h_get_32 ((abfd), (bfd_byte *) (where))
 967 .
 968 .#define H_GET_16(abfd, where) \
 969 .  bfd_h_get_16 ((abfd), (bfd_byte *) (where))
 970 .
 971 .#define H_GET_8 bfd_h_get_8
 972 .
 973 .#define H_GET_S64(abfd, where) \
 974 .  bfd_h_get_signed_64 ((abfd), (bfd_byte *) (where))
 975 .
 976 .#define H_GET_S32(abfd, where) \
 977 .  bfd_h_get_signed_32 ((abfd), (bfd_byte *) (where))
 978 .
 979 .#define H_GET_S16(abfd, where) \
 980 .  bfd_h_get_signed_16 ((abfd), (bfd_byte *) (where))
 981 .
 982 .#define H_GET_S8 bfd_h_get_signed_8
 983 .
 984 .*/
 985
 986 /* Sign extension to bfd_signed_vma.  */
 987 #define COERCE16(x) (((bfd_signed_vma) (x) ^ 0x8000) - 0x8000)
 988 #define COERCE32(x) \
 989   ((bfd_signed_vma) (long) (((unsigned long) (x) ^ 0x80000000) - 0x80000000))
 990 #define EIGHT_GAZILLION (((BFD_HOST_64_BIT)0x80000000) << 32)
 991 #define COERCE64(x) \
 992   (((bfd_signed_vma) (x) ^ EIGHT_GAZILLION) - EIGHT_GAZILLION)
 993
 994 bfd_vma
 995 bfd_getb16 (addr)
 996      register const bfd_byte *addr;
 997 {
 998   return (addr[0] << 8) | addr[1];
 999 }
1000
1001 bfd_vma
1002 bfd_getl16 (addr)
1003      register const bfd_byte *addr;
1004 {
1005   return (addr[1] << 8) | addr[0];
1006 }
1007
1008 bfd_signed_vma
1009 bfd_getb_signed_16 (addr)
1010      register const bfd_byte *addr;
1011 {
1012   return COERCE16((addr[0] << 8) | addr[1]);
1013 }
1014
1015 bfd_signed_vma
1016 bfd_getl_signed_16 (addr)
1017      register const bfd_byte *addr;
1018 {
1019   return COERCE16((addr[1] << 8) | addr[0]);
1020 }
1021
1022 void
1023 bfd_putb16 (data, addr)
1024      bfd_vma data;
1025      register bfd_byte *addr;
1026 {
1027   addr[0] = (bfd_byte) (data >> 8);
1028   addr[1] = (bfd_byte) data;
1029 }
1030
1031 void
1032 bfd_putl16 (data, addr)
1033      bfd_vma data;
1034      register bfd_byte *addr;
1035 {
1036   addr[0] = (bfd_byte) data;
1037   addr[1] = (bfd_byte) (data >> 8);
1038 }
1039
1040 bfd_vma
1041 bfd_getb32 (addr)
1042      register const bfd_byte *addr;
1043 {
1044   unsigned long v;
1045
1046   v = (unsigned long) addr[0] << 24;
1047   v |= (unsigned long) addr[1] << 16;
1048   v |= (unsigned long) addr[2] << 8;
1049   v |= (unsigned long) addr[3];
1050   return (bfd_vma) v;
1051 }
1052
1053 bfd_vma
1054 bfd_getl32 (addr)
1055      register const bfd_byte *addr;
1056 {
1057   unsigned long v;
1058
1059   v = (unsigned long) addr[0];
1060   v |= (unsigned long) addr[1] << 8;
1061   v |= (unsigned long) addr[2] << 16;
1062   v |= (unsigned long) addr[3] << 24;
1063   return (bfd_vma) v;
1064 }
1065
1066 bfd_signed_vma
1067 bfd_getb_signed_32 (addr)
1068      register const bfd_byte *addr;
1069 {
1070   unsigned long v;
1071
1072   v = (unsigned long) addr[0] << 24;
1073   v |= (unsigned long) addr[1] << 16;
1074   v |= (unsigned long) addr[2] << 8;
1075   v |= (unsigned long) addr[3];
1076   return COERCE32 (v);
1077 }
1078
1079 bfd_signed_vma
1080 bfd_getl_signed_32 (addr)
1081      register const bfd_byte *addr;
1082 {
1083   unsigned long v;
1084
1085   v = (unsigned long) addr[0];
1086   v |= (unsigned long) addr[1] << 8;
1087   v |= (unsigned long) addr[2] << 16;
1088   v |= (unsigned long) addr[3] << 24;
1089   return COERCE32 (v);
1090 }
1091
1092 bfd_vma
1093 bfd_getb64 (addr)
1094      register const bfd_byte *addr ATTRIBUTE_UNUSED;
1095 {
1096 #ifdef BFD64
1097   bfd_vma low, high;
1098
1099   high= ((((((((addr[0]) << 8) |
1100               addr[1]) << 8) |
1101             addr[2]) << 8) |
1102           addr[3]) );
1103
1104   low = (((((((((bfd_vma)addr[4]) << 8) |
1105               addr[5]) << 8) |
1106             addr[6]) << 8) |
1107           addr[7]));
1108
1109   return high << 32 | low;
1110 #else
1111   BFD_FAIL();
1112   return 0;
1113 #endif
1114 }
1115
1116 bfd_vma
1117 bfd_getl64 (addr)
1118      register const bfd_byte *addr ATTRIBUTE_UNUSED;
1119 {
1120 #ifdef BFD64
1121   bfd_vma low, high;
1122   high= (((((((addr[7] << 8) |
1123               addr[6]) << 8) |
1124             addr[5]) << 8) |
1125           addr[4]));
1126
1127   low = ((((((((bfd_vma)addr[3] << 8) |
1128               addr[2]) << 8) |
1129             addr[1]) << 8) |
1130           addr[0]) );
1131
1132   return high << 32 | low;
1133 #else
1134   BFD_FAIL();
1135   return 0;
1136 #endif
1137
1138 }
1139
1140 bfd_signed_vma
1141 bfd_getb_signed_64 (addr)
1142      register const bfd_byte *addr ATTRIBUTE_UNUSED;
1143 {
1144 #ifdef BFD64
1145   bfd_vma low, high;
1146
1147   high= ((((((((addr[0]) << 8) |
1148               addr[1]) << 8) |
1149             addr[2]) << 8) |
1150           addr[3]) );
1151
1152   low = (((((((((bfd_vma)addr[4]) << 8) |
1153               addr[5]) << 8) |
1154             addr[6]) << 8) |
1155           addr[7]));
1156
1157   return COERCE64(high << 32 | low);
1158 #else
1159   BFD_FAIL();
1160   return 0;
1161 #endif
1162 }
1163
1164 bfd_signed_vma
1165 bfd_getl_signed_64 (addr)
1166      register const bfd_byte *addr ATTRIBUTE_UNUSED;
1167 {
1168 #ifdef BFD64
1169   bfd_vma low, high;
1170   high= (((((((addr[7] << 8) |
1171               addr[6]) << 8) |
1172             addr[5]) << 8) |
1173           addr[4]));
1174
1175   low = ((((((((bfd_vma)addr[3] << 8) |
1176               addr[2]) << 8) |
1177             addr[1]) << 8) |
1178           addr[0]) );
1179
1180   return COERCE64(high << 32 | low);
1181 #else
1182   BFD_FAIL();
1183   return 0;
1184 #endif
1185 }
1186
1187 void
1188 bfd_putb32 (data, addr)
1189      bfd_vma data;
1190      register bfd_byte *addr;
1191 {
1192         addr[0] = (bfd_byte) (data >> 24);
1193         addr[1] = (bfd_byte) (data >> 16);
1194         addr[2] = (bfd_byte) (data >>  8);
1195         addr[3] = (bfd_byte) data;
1196 }
1197
1198 void
1199 bfd_putl32 (data, addr)
1200      bfd_vma data;
1201      register bfd_byte *addr;
1202 {
1203         addr[0] = (bfd_byte) data;
1204         addr[1] = (bfd_byte) (data >>  8);
1205         addr[2] = (bfd_byte) (data >> 16);
1206         addr[3] = (bfd_byte) (data >> 24);
1207 }
1208
1209 void
1210 bfd_putb64 (data, addr)
1211      bfd_vma data ATTRIBUTE_UNUSED;
1212      register bfd_byte *addr ATTRIBUTE_UNUSED;
1213 {
1214 #ifdef BFD64
1215   addr[0] = (bfd_byte) (data >> (7*8));
1216   addr[1] = (bfd_byte) (data >> (6*8));
1217   addr[2] = (bfd_byte) (data >> (5*8));
1218   addr[3] = (bfd_byte) (data >> (4*8));
1219   addr[4] = (bfd_byte) (data >> (3*8));
1220   addr[5] = (bfd_byte) (data >> (2*8));
1221   addr[6] = (bfd_byte) (data >> (1*8));
1222   addr[7] = (bfd_byte) (data >> (0*8));
1223 #else
1224   BFD_FAIL();
1225 #endif
1226 }
1227
1228 void
1229 bfd_putl64 (data, addr)
1230      bfd_vma data ATTRIBUTE_UNUSED;
1231      register bfd_byte *addr ATTRIBUTE_UNUSED;
1232 {
1233 #ifdef BFD64
1234   addr[7] = (bfd_byte) (data >> (7*8));
1235   addr[6] = (bfd_byte) (data >> (6*8));
1236   addr[5] = (bfd_byte) (data >> (5*8));
1237   addr[4] = (bfd_byte) (data >> (4*8));
1238   addr[3] = (bfd_byte) (data >> (3*8));
1239   addr[2] = (bfd_byte) (data >> (2*8));
1240   addr[1] = (bfd_byte) (data >> (1*8));
1241   addr[0] = (bfd_byte) (data >> (0*8));
1242 #else
1243   BFD_FAIL();
1244 #endif
1245 }
1246
1247 void
1248 bfd_put_bits (data, addr, bits, big_p)
1249      bfd_vma data;
1250      bfd_byte *addr;
1251      int bits;
1252      boolean big_p;
1253 {
1254   int i;
1255   int bytes;
1256
1257   if (bits % 8 != 0)
1258     abort ();
1259
1260   bytes = bits / 8;
1261   for (i = 0; i < bytes; i++)
1262     {
1263       int index = big_p ? bytes - i - 1 : i;
1264
1265       addr[index] = (bfd_byte) data;
1266       data >>= 8;
1267     }
1268 }
1269
1270 bfd_vma
1271 bfd_get_bits (addr, bits, big_p)
1272      bfd_byte *addr;
1273      int bits;
1274      boolean big_p;
1275 {
1276   bfd_vma data;
1277   int i;
1278   int bytes;
1279
1280   if (bits % 8 != 0)
1281     abort ();
1282
1283   data = 0;
1284   bytes = bits / 8;
1285   for (i = 0; i < bytes; i++)
1286     {
1287       int index = big_p ? i : bytes - i - 1;
1288
1289       data = (data << 8) | addr[index];
1290     }
1291
1292   return data;
1293 }
1294 \f
1295 /* Default implementation */
1296
1297 boolean
1298 _bfd_generic_get_section_contents (abfd, section, location, offset, count)
1299      bfd *abfd;
1300      sec_ptr section;
1301      PTR location;
1302      file_ptr offset;
1303      bfd_size_type count;
1304 {
1305   if (count == 0)
1306     return true;
1307
1308   if (offset + count > section->_raw_size)
1309     {
1310       bfd_set_error (bfd_error_invalid_operation);
1311       return false;
1312     }
1313
1314   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1315       || bfd_bread (location, count, abfd) != count)
1316     return false;
1317
1318   return true;
1319 }
1320
1321 boolean
1322 _bfd_generic_get_section_contents_in_window (abfd, section, w, offset, count)
1323      bfd *abfd ATTRIBUTE_UNUSED;
1324      sec_ptr section ATTRIBUTE_UNUSED;
1325      bfd_window *w ATTRIBUTE_UNUSED;
1326      file_ptr offset ATTRIBUTE_UNUSED;
1327      bfd_size_type count ATTRIBUTE_UNUSED;
1328 {
1329 #ifdef USE_MMAP
1330   if (count == 0)
1331     return true;
1332   if (abfd->xvec->_bfd_get_section_contents != _bfd_generic_get_section_contents)
1333     {
1334       /* We don't know what changes the bfd's get_section_contents
1335          method may have to make.  So punt trying to map the file
1336          window, and let get_section_contents do its thing.  */
1337       /* @@ FIXME : If the internal window has a refcount of 1 and was
1338          allocated with malloc instead of mmap, just reuse it.  */
1339       bfd_free_window (w);
1340       w->i = ((bfd_window_internal *)
1341               bfd_zmalloc ((bfd_size_type) sizeof (bfd_window_internal)));
1342       if (w->i == NULL)
1343         return false;
1344       w->i->data = (PTR) bfd_malloc (count);
1345       if (w->i->data == NULL)
1346         {
1347           free (w->i);
1348           w->i = NULL;
1349           return false;
1350         }
1351       w->i->mapped = 0;
1352       w->i->refcount = 1;
1353       w->size = w->i->size = count;
1354       w->data = w->i->data;
1355       return bfd_get_section_contents (abfd, section, w->data, offset, count);
1356     }
1357   if (offset + count > section->_raw_size
1358       || (bfd_get_file_window (abfd, section->filepos + offset, count, w, true)
1359           == false))
1360     return false;
1361   return true;
1362 #else
1363   abort ();
1364 #endif
1365 }
1366
1367 /* This generic function can only be used in implementations where creating
1368    NEW sections is disallowed.  It is useful in patching existing sections
1369    in read-write files, though.  See other set_section_contents functions
1370    to see why it doesn't work for new sections.  */
1371 boolean
1372 _bfd_generic_set_section_contents (abfd, section, location, offset, count)
1373      bfd *abfd;
1374      sec_ptr section;
1375      PTR location;
1376      file_ptr offset;
1377      bfd_size_type count;
1378 {
1379   if (count == 0)
1380     return true;
1381
1382   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1383       || bfd_bwrite (location, count, abfd) != count)
1384     return false;
1385
1386   return true;
1387 }
1388
1389 /*
1390 INTERNAL_FUNCTION
1391         bfd_log2
1392
1393 SYNOPSIS
1394         unsigned int bfd_log2 (bfd_vma x);
1395
1396 DESCRIPTION
1397         Return the log base 2 of the value supplied, rounded up.  E.g., an
1398         @var{x} of 1025 returns 11.  A @var{x} of 0 returns 0.
1399 */
1400
1401 unsigned int
1402 bfd_log2 (x)
1403      bfd_vma x;
1404 {
1405   unsigned int result = 0;
1406
1407   while ((x = (x >> 1)) != 0)
1408     ++result;
1409   return result;
1410 }
1411
1412 boolean
1413 bfd_generic_is_local_label_name (abfd, name)
1414      bfd *abfd;
1415      const char *name;
1416 {
1417   char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
1418
1419   return (name[0] == locals_prefix);
1420 }
1421
1422 /*  Can be used from / for bfd_merge_private_bfd_data to check that
1423     endianness matches between input and output file.  Returns
1424     true for a match, otherwise returns false and emits an error.  */
1425 boolean
1426 _bfd_generic_verify_endian_match (ibfd, obfd)
1427      bfd *ibfd;
1428      bfd *obfd;
1429 {
1430   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1431       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1432       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1433     {
1434       const char *msg;
1435
1436       if (bfd_big_endian (ibfd))
1437         msg = _("%s: compiled for a big endian system and target is little endian");
1438       else
1439         msg = _("%s: compiled for a little endian system and target is big endian");
1440
1441       (*_bfd_error_handler) (msg, bfd_archive_filename (ibfd));
1442
1443       bfd_set_error (bfd_error_wrong_format);
1444       return false;
1445     }
1446
1447   return true;
1448 }
1449
1450 /* Give a warning at runtime if someone compiles code which calls
1451    old routines.  */
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       fprintf (stderr, _("Deprecated %s called"), what);
1465       if (func)
1466         fprintf (stderr, _(" at %s line %d in %s\n"), file, line, func);
1467       else
1468         fprintf (stderr, "\n");
1469       mask |= ~(size_t) func;
1470     }
1471 }