* coff-sh.c (sh_coff_howtos): Mark R_SH_PCDISP8BY2 and R_SH_PCDISP

[deliverable/binutils-gdb.git] / bfd / libbfd.c

diff --git a/bfd/libbfd.c b/bfd/libbfd.c
index 8e20e3e90a730d3f601fb0a10f5f267d6be80dcf..2925754cbd764056afb3f60adae26449ceabb478 100644 (file)
--- a/bfd/libbfd.c
+++ b/bfd/libbfd.c
@@ -1,5 +1,5 @@
 /* Assorted BFD support routines, only used internally.
 /* Assorted BFD support routines, only used internally.

-   Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
+   Copyright 1990, 91, 92, 93, 94 Free Software Foundation, Inc.

    Written by Cygnus Support.
 
 This file is part of BFD, the Binary File Descriptor library.
    Written by Cygnus Support.
 
 This file is part of BFD, the Binary File Descriptor library.


@@ -32,164 +32,142 @@ DESCRIPTION
        completeness.
 */
 
        completeness.
 */
 

-/*ARGSUSED*/
-boolean
-DEFUN(_bfd_dummy_new_section_hook,(ignore, ignore_newsect),
-      bfd *ignore AND
-      asection *ignore_newsect)
-{
-  return true;
-}
+/* A routine which is used in target vectors for unsupported
+   operations.  */

 
 /*ARGSUSED*/
 boolean
 
 /*ARGSUSED*/
 boolean

-DEFUN(bfd_false ,(ignore),
-      bfd *ignore)
+bfd_false (ignore)
+     bfd *ignore;

 {
 {

+  bfd_set_error (bfd_error_invalid_operation);

   return false;
 }
 
   return false;
 }
 

+/* A routine which is used in target vectors for supported operations
+   which do not actually do anything.  */
+

 /*ARGSUSED*/
 boolean
 /*ARGSUSED*/
 boolean

-DEFUN(bfd_true,(ignore),
-      bfd *ignore)
+bfd_true (ignore)
+     bfd *ignore;

 {
   return true;
 }
 
 {
   return true;
 }
 

+/* A routine which is used in target vectors for unsupported
+   operations which return a pointer value.  */
+

 /*ARGSUSED*/
 PTR
 /*ARGSUSED*/
 PTR

-DEFUN(bfd_nullvoidptr,(ignore),
-      bfd *ignore)
+bfd_nullvoidptr (ignore)
+     bfd *ignore;

 {
 {

-  return (PTR)NULL;
+  bfd_set_error (bfd_error_invalid_operation);
+  return NULL;

 }
 
 /*ARGSUSED*/
 int 
 }
 
 /*ARGSUSED*/
 int 

-DEFUN(bfd_0,(ignore),
-      bfd *ignore)
+bfd_0 (ignore)
+     bfd *ignore;

 {
   return 0;
 }
 
 /*ARGSUSED*/
 unsigned int 
 {
   return 0;
 }
 
 /*ARGSUSED*/
 unsigned int 

-DEFUN(bfd_0u,(ignore),
-      bfd *ignore)
+bfd_0u (ignore)
+     bfd *ignore;

 {
    return 0;
 }
 
 {
    return 0;
 }
 

+/*ARGUSED*/
+long
+bfd_0l (ignore)
+     bfd *ignore;
+{
+  return 0;
+}
+
+/* A routine which is used in target vectors for unsupported
+   operations which return -1 on error.  */
+
+/*ARGSUSED*/
+long
+_bfd_n1 (ignore_abfd)
+     bfd *ignore_abfd;
+{
+  bfd_set_error (bfd_error_invalid_operation);
+  return -1;
+}
+

 /*ARGSUSED*/
 void 
 /*ARGSUSED*/
 void 

-DEFUN(bfd_void,(ignore),
-      bfd *ignore)
+bfd_void (ignore)
+     bfd *ignore;

 {
 }
 
 /*ARGSUSED*/
 boolean
 {
 }
 
 /*ARGSUSED*/
 boolean

-DEFUN(_bfd_dummy_core_file_matches_executable_p,(ignore_core_bfd, ignore_exec_bfd),
-      bfd *ignore_core_bfd AND
-      bfd *ignore_exec_bfd)
+_bfd_nocore_core_file_matches_executable_p (ignore_core_bfd, ignore_exec_bfd)
+     bfd *ignore_core_bfd;
+     bfd *ignore_exec_bfd;

 {
 {

-  bfd_error = invalid_operation;
+  bfd_set_error (bfd_error_invalid_operation);

   return false;
 }
 
   return false;
 }
 

-/* of course you can't initialize a function to be the same as another, grr */
+/* Routine to handle core_file_failing_command entry point for targets
+   without core file support.  */

 
 /*ARGSUSED*/
 char *
 
 /*ARGSUSED*/
 char *

-DEFUN(_bfd_dummy_core_file_failing_command,(ignore_abfd),
-      bfd *ignore_abfd)
+_bfd_nocore_core_file_failing_command (ignore_abfd)
+     bfd *ignore_abfd;

 {
 {

+  bfd_set_error (bfd_error_invalid_operation);

   return (char *)NULL;
 }
 
   return (char *)NULL;
 }
 

+/* Routine to handle core_file_failing_signal entry point for targets
+   without core file support.  */
+

 /*ARGSUSED*/
 int
 /*ARGSUSED*/
 int

-DEFUN(_bfd_dummy_core_file_failing_signal,(ignore_abfd),
-     bfd *ignore_abfd)
+_bfd_nocore_core_file_failing_signal (ignore_abfd)
+     bfd *ignore_abfd;

 {
 {

+  bfd_set_error (bfd_error_invalid_operation);

   return 0;
 }
 
 /*ARGSUSED*/
 bfd_target *
   return 0;
 }
 
 /*ARGSUSED*/
 bfd_target *

-DEFUN(_bfd_dummy_target,(ignore_abfd),
-     bfd *ignore_abfd)
+_bfd_dummy_target (ignore_abfd)
+     bfd *ignore_abfd;

 {
   return 0;
 }
 \f
 {
   return 0;
 }
 \f

-/** zalloc -- allocate and clear storage */

 
 

+#ifndef bfd_zmalloc
+/* allocate and clear storage */

 
 

-#ifndef zalloc

 char *
 char *

-DEFUN(zalloc,(size),
-      bfd_size_type size)
+bfd_zmalloc (size)
+     bfd_size_type size;

 {
 {

-  char *ptr = (char *) malloc ((size_t)size);
-
-  if ((ptr != NULL) && (size != 0))
-   memset(ptr,0, (size_t) size);
-
-  return ptr;
-}
-#endif
+  char *ptr = (char *) malloc ((size_t) size);

 
 

-/*
-INTERNAL_FUNCTION
-       bfd_xmalloc
-
-SYNOPSIS
-       PTR  bfd_xmalloc (bfd_size_type size);
+  if (ptr && size)
+   memset(ptr, 0, (size_t) size);

 
 

-DESCRIPTION
-       Like <<malloc>>, but exit if no more memory.
-
-*/
-
-/** There is major inconsistency in how running out of memory is handled.
-  Some routines return a NULL, and set bfd_error to no_memory.
-  However, obstack routines can't do this ... */
-
-
-DEFUN(PTR bfd_xmalloc,(size),
-      bfd_size_type size)
-{
-  static CONST char no_memory_message[] = "Virtual memory exhausted!\n";
-  PTR ptr;
-  if (size == 0) size = 1;
-  ptr = (PTR)malloc((size_t) size);
-  if (!ptr)
-    {
-      write (2, no_memory_message, sizeof(no_memory_message)-1);
-      exit (1);
-    }

   return ptr;
 }
   return ptr;
 }

-
-/*
-INTERNAL_FUNCTION
-       bfd_xmalloc_by_size_t
-
-SYNOPSIS
-       PTR bfd_xmalloc_by_size_t (size_t size);
-
-DESCRIPTION
-       Like <<malloc>>, but exit if no more memory.
-       Uses <<size_t>>, so it's suitable for use as <<obstack_chunk_alloc>>.
- */
-PTR
-DEFUN(bfd_xmalloc_by_size_t, (size),
-      size_t size)
-{
-  return bfd_xmalloc ((bfd_size_type) size);
-}
+#endif /* bfd_zmalloc */

 \f
 /* Some IO code */
 
 \f
 /* Some IO code */
 


@@ -202,20 +180,25 @@ DEFUN(bfd_xmalloc_by_size_t, (size),
    first octet in the file, NOT the beginning of the archive header. */
 
 static 
    first octet in the file, NOT the beginning of the archive header. */
 
 static 

-int DEFUN(real_read,(where, a,b, file),
-          PTR where AND
-          int a AND
-          int b AND
-          FILE *file)
+int
+real_read (where, a,b, file)
+     PTR where;
+     int a;
+     int b;
+     FILE *file;

 {
   return fread(where, a,b,file);
 }
 {
   return fread(where, a,b,file);
 }

+
+/* Return value is amount read (FIXME: how are errors and end of file dealt
+   with?  We never call bfd_set_error, which is probably a mistake).  */
+

 bfd_size_type
 bfd_size_type

-DEFUN(bfd_read,(ptr, size, nitems, abfd),
-      PTR ptr AND
-      bfd_size_type size AND
-      bfd_size_type nitems AND
-      bfd *abfd)
+bfd_read (ptr, size, nitems, abfd)
+     PTR ptr;
+     bfd_size_type size;
+     bfd_size_type nitems;
+     bfd *abfd;

 {
   int nread;
   nread = real_read (ptr, 1, (int)(size*nitems), bfd_cache_lookup(abfd));
 {
   int nread;
   nread = real_read (ptr, 1, (int)(size*nitems), bfd_cache_lookup(abfd));


@@ -223,6 +206,22 @@ DEFUN(bfd_read,(ptr, size, nitems, abfd),
   if (nread > 0)
     abfd->where += nread;
 #endif
   if (nread > 0)
     abfd->where += nread;
 #endif

+
+  /* Set bfd_error if we did not read as much data as we expected.
+
+     If the read failed due to an error set the bfd_error_system_call,
+     else set bfd_error_file_truncated.
+
+     A BFD backend may wish to override bfd_error_file_truncated to
+     provide something more useful (eg. no_symbols or wrong_format).  */
+  if (nread < (int)(size * nitems))
+    {
+      if (ferror (bfd_cache_lookup (abfd)))
+       bfd_set_error (bfd_error_system_call);
+      else
+       bfd_set_error (bfd_error_file_truncated);
+    }
+

   return nread;
 }
 
   return nread;
 }
 


@@ -244,7 +243,7 @@ bfd_write (ptr, size, nitems, abfd)
       if (nwrote >= 0)
        errno = ENOSPC;
 #endif
       if (nwrote >= 0)
        errno = ENOSPC;
 #endif

-      bfd_error = system_call_error;
+      bfd_set_error (bfd_error_system_call);

     }
   return nwrote;
 }
     }
   return nwrote;
 }


@@ -263,18 +262,19 @@ DESCRIPTION
 
 */
 void
 
 */
 void

-DEFUN(bfd_write_bigendian_4byte_int,(abfd, i),
-      bfd *abfd AND
-      int i)
+bfd_write_bigendian_4byte_int (abfd, i)
+     bfd *abfd;
+     int i;

 {
   bfd_byte buffer[4];
   bfd_putb32(i, buffer);
 {
   bfd_byte buffer[4];
   bfd_putb32(i, buffer);

-  bfd_write((PTR)buffer, 4, 1, abfd);
+  if (bfd_write((PTR)buffer, 4, 1, abfd) != 4)
+    abort ();

 }
 
 long
 }
 
 long

-DEFUN(bfd_tell,(abfd),
-      bfd *abfd)
+bfd_tell (abfd)
+     bfd *abfd;

 {
   file_ptr ptr;
 
 {
   file_ptr ptr;
 


@@ -287,25 +287,28 @@ DEFUN(bfd_tell,(abfd),
 }
 
 int
 }
 
 int

-DEFUN(bfd_flush,(abfd),
-      bfd *abfd)
+bfd_flush (abfd)
+     bfd *abfd;

 {
   return fflush (bfd_cache_lookup(abfd));
 }
 
 int
 {
   return fflush (bfd_cache_lookup(abfd));
 }
 
 int

-DEFUN(bfd_stat,(abfd, statbuf),
-      bfd *abfd AND
-      struct stat *statbuf)
+bfd_stat (abfd, statbuf)
+     bfd *abfd;
+     struct stat *statbuf;

 {
   return fstat (fileno(bfd_cache_lookup(abfd)), statbuf);
 }
 
 {
   return fstat (fileno(bfd_cache_lookup(abfd)), statbuf);
 }
 

+/* Returns 0 for success, nonzero for failure (in which case bfd_get_error
+   can retrieve the error code).  */
+

 int
 int

-DEFUN(bfd_seek,(abfd, position, direction),
-      bfd * CONST abfd AND
-      CONST file_ptr position AND
-      CONST int direction)
+bfd_seek (abfd, position, direction)
+     bfd * CONST abfd;
+     CONST file_ptr position;
+     CONST int direction;

 {
   int result;
   FILE *f;
 {
   int result;
   FILE *f;


@@ -365,7 +368,7 @@ DEFUN(bfd_seek,(abfd, position, direction),
     {
       /* Force redetermination of `where' field.  */
       bfd_tell (abfd);
     {
       /* Force redetermination of `where' field.  */
       bfd_tell (abfd);

-      bfd_error = system_call_error;
+      bfd_set_error (bfd_error_system_call);

     }
   else
     {
     }
   else
     {


@@ -388,11 +391,11 @@ DEFUN(bfd_seek,(abfd, position, direction),
    table_length).  Updates free_ptr, table, table_length */
 
 boolean
    table_length).  Updates free_ptr, table, table_length */
 
 boolean

-DEFUN(bfd_add_to_string_table,(table, new_string, table_length, free_ptr),
-      char **table AND
-      char *new_string AND
-      unsigned int *table_length AND
-      char **free_ptr)
+bfd_add_to_string_table (table, new_string, table_length, free_ptr)
+     char **table;
+     char *new_string;
+     unsigned int *table_length;
+     char **free_ptr;

 {
   size_t string_length = strlen (new_string) + 1; /* include null here */
   char *base = *table;
 {
   size_t string_length = strlen (new_string) + 1; /* include null here */
   char *base = *table;


@@ -401,13 +404,13 @@ DEFUN(bfd_add_to_string_table,(table, new_string, table_length, free_ptr),
 
   if (base == NULL) {
     /* Avoid a useless regrow if we can (but of course we still
 
   if (base == NULL) {
     /* Avoid a useless regrow if we can (but of course we still

-       take it next time */
+       take it next time).  */

     space_length = (string_length < DEFAULT_STRING_SPACE_SIZE ?
                     DEFAULT_STRING_SPACE_SIZE : string_length+1);
     space_length = (string_length < DEFAULT_STRING_SPACE_SIZE ?
                     DEFAULT_STRING_SPACE_SIZE : string_length+1);

-    base = zalloc ((bfd_size_type) space_length);
+    base = bfd_zmalloc ((bfd_size_type) space_length);

 
     if (base == NULL) {
 
     if (base == NULL) {

-      bfd_error = no_memory;
+      bfd_set_error (bfd_error_no_memory);

       return false;
     }
   }
       return false;
     }
   }


@@ -419,7 +422,7 @@ DEFUN(bfd_add_to_string_table,(table, new_string, table_length, free_ptr),
 
     base = (char *) realloc (base, space_length);
     if (base == NULL) {
 
     base = (char *) realloc (base, space_length);
     if (base == NULL) {

-      bfd_error = no_memory;
+      bfd_set_error (bfd_error_no_memory);

       return false;
     }
 
       return false;
     }
 


@@ -564,91 +567,91 @@ DESCRIPTION
 /* Sign extension to bfd_signed_vma.  */
 #define COERCE16(x) (((bfd_signed_vma) (x) ^ 0x8000) - 0x8000)
 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
 /* Sign extension to bfd_signed_vma.  */
 #define COERCE16(x) (((bfd_signed_vma) (x) ^ 0x8000) - 0x8000)
 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)

-#define EIGHT_GAZILLION (((HOST_64_BIT)0x80000000) << 32)
+#define EIGHT_GAZILLION (((BFD_HOST_64_BIT)0x80000000) << 32)

 #define COERCE64(x) \
   (((bfd_signed_vma) (x) ^ EIGHT_GAZILLION) - EIGHT_GAZILLION)
 
 bfd_vma
 #define COERCE64(x) \
   (((bfd_signed_vma) (x) ^ EIGHT_GAZILLION) - EIGHT_GAZILLION)
 
 bfd_vma

-DEFUN(bfd_getb16,(addr),
-      register bfd_byte *addr)
+bfd_getb16 (addr)
+     register const bfd_byte *addr;

 {
 {

-        return (addr[0] << 8) | addr[1];
+  return (addr[0] << 8) | addr[1];

 }
 
 bfd_vma
 }
 
 bfd_vma

-DEFUN(bfd_getl16,(addr),
-      register bfd_byte *addr)
+bfd_getl16 (addr)
+     register const bfd_byte *addr;

 {
 {

-        return (addr[1] << 8) | addr[0];
+  return (addr[1] << 8) | addr[0];

 }
 
 bfd_signed_vma
 }
 
 bfd_signed_vma

-DEFUN(bfd_getb_signed_16,(addr),
-      register bfd_byte *addr)
+bfd_getb_signed_16 (addr)
+     register const bfd_byte *addr;

 {
 {

-        return COERCE16((addr[0] << 8) | addr[1]);
+  return COERCE16((addr[0] << 8) | addr[1]);

 }
 
 bfd_signed_vma
 }
 
 bfd_signed_vma

-DEFUN(bfd_getl_signed_16,(addr),
-      register bfd_byte *addr)
+bfd_getl_signed_16 (addr)
+     register const bfd_byte *addr;

 {
 {

-        return COERCE16((addr[1] << 8) | addr[0]);
+  return COERCE16((addr[1] << 8) | addr[0]);

 }
 
 void
 }
 
 void

-DEFUN(bfd_putb16,(data, addr),
-      bfd_vma data AND
-      register bfd_byte *addr)
+bfd_putb16 (data, addr)
+     bfd_vma data;
+     register bfd_byte *addr;

 {
 {

-        addr[0] = (bfd_byte)(data >> 8);
-        addr[1] = (bfd_byte )data;
+  addr[0] = (bfd_byte)(data >> 8);
+  addr[1] = (bfd_byte )data;

 }
 
 void
 }
 
 void

-DEFUN(bfd_putl16,(data, addr),
-      bfd_vma data AND              
-      register bfd_byte *addr)
+bfd_putl16 (data, addr)
+     bfd_vma data;             
+     register bfd_byte *addr;

 {
 {

-        addr[0] = (bfd_byte )data;
-        addr[1] = (bfd_byte)(data >> 8);
+  addr[0] = (bfd_byte )data;
+  addr[1] = (bfd_byte)(data >> 8);

 }
 
 bfd_vma
 bfd_getb32 (addr)
 }
 
 bfd_vma
 bfd_getb32 (addr)

-     register bfd_byte *addr;
+     register const bfd_byte *addr;

 {
 {

-        return (((((bfd_vma)addr[0] << 8) | addr[1]) << 8)
-               | addr[2]) << 8 | addr[3];
+  return (((((bfd_vma)addr[0] << 8) | addr[1]) << 8)
+         | addr[2]) << 8 | addr[3];

 }
 
 bfd_vma
 bfd_getl32 (addr)
 }
 
 bfd_vma
 bfd_getl32 (addr)

-        register bfd_byte *addr;
+     register const bfd_byte *addr;

 {
 {

-        return (((((bfd_vma)addr[3] << 8) | addr[2]) << 8)
-               | addr[1]) << 8 | addr[0];
+  return (((((bfd_vma)addr[3] << 8) | addr[2]) << 8)
+         | addr[1]) << 8 | addr[0];

 }
 
 bfd_signed_vma
 bfd_getb_signed_32 (addr)
 }
 
 bfd_signed_vma
 bfd_getb_signed_32 (addr)

-     register bfd_byte *addr;
+     register const bfd_byte *addr;

 {
 {

-        return COERCE32((((((bfd_vma)addr[0] << 8) | addr[1]) << 8)
-                        | addr[2]) << 8 | addr[3]);
+  return COERCE32((((((bfd_vma)addr[0] << 8) | addr[1]) << 8)
+                  | addr[2]) << 8 | addr[3]);

 }
 
 bfd_signed_vma
 bfd_getl_signed_32 (addr)
 }
 
 bfd_signed_vma
 bfd_getl_signed_32 (addr)

-        register bfd_byte *addr;
+     register const bfd_byte *addr;

 {
 {

-        return COERCE32((((((bfd_vma)addr[3] << 8) | addr[2]) << 8)
-                        | addr[1]) << 8 | addr[0]);
+  return COERCE32((((((bfd_vma)addr[3] << 8) | addr[2]) << 8)
+                  | addr[1]) << 8 | addr[0]);

 }
 
 bfd_vma
 }
 
 bfd_vma

-DEFUN(bfd_getb64,(addr),
-      register bfd_byte *addr)
+bfd_getb64 (addr)
+     register const bfd_byte *addr;

 {
 #ifdef BFD64
   bfd_vma low, high;
 {
 #ifdef BFD64
   bfd_vma low, high;


@@ -668,14 +671,12 @@ DEFUN(bfd_getb64,(addr),
   BFD_FAIL();
   return 0;
 #endif
   BFD_FAIL();
   return 0;
 #endif

-

 }
 
 bfd_vma
 }
 
 bfd_vma

-DEFUN(bfd_getl64,(addr),
-      register bfd_byte *addr)
+bfd_getl64 (addr)
+     register const bfd_byte *addr;

 {
 {

-

 #ifdef BFD64
   bfd_vma low, high;
   high= (((((((addr[7] << 8) |
 #ifdef BFD64
   bfd_vma low, high;
   high= (((((((addr[7] << 8) |


@@ -697,8 +698,8 @@ DEFUN(bfd_getl64,(addr),
 }
 
 bfd_signed_vma
 }
 
 bfd_signed_vma

-DEFUN(bfd_getb_signed_64,(addr),
-      register bfd_byte *addr)
+bfd_getb_signed_64 (addr)
+     register const bfd_byte *addr;

 {
 #ifdef BFD64
   bfd_vma low, high;
 {
 #ifdef BFD64
   bfd_vma low, high;


@@ -718,14 +719,12 @@ DEFUN(bfd_getb_signed_64,(addr),
   BFD_FAIL();
   return 0;
 #endif
   BFD_FAIL();
   return 0;
 #endif

-

 }
 
 bfd_signed_vma
 }
 
 bfd_signed_vma

-DEFUN(bfd_getl_signed_64,(addr),
-      register bfd_byte *addr)
+bfd_getl_signed_64 (addr)
+     register const bfd_byte *addr;

 {
 {

-

 #ifdef BFD64
   bfd_vma low, high;
   high= (((((((addr[7] << 8) |
 #ifdef BFD64
   bfd_vma low, high;
   high= (((((((addr[7] << 8) |


@@ -743,13 +742,12 @@ DEFUN(bfd_getl_signed_64,(addr),
   BFD_FAIL();
   return 0;
 #endif
   BFD_FAIL();
   return 0;
 #endif

-

 }
 
 void
 }
 
 void

-DEFUN(bfd_putb32,(data, addr),
-      bfd_vma data AND
-      register bfd_byte *addr)
+bfd_putb32 (data, addr)
+     bfd_vma data;
+     register bfd_byte *addr;

 {
         addr[0] = (bfd_byte)(data >> 24);
         addr[1] = (bfd_byte)(data >> 16);
 {
         addr[0] = (bfd_byte)(data >> 24);
         addr[1] = (bfd_byte)(data >> 16);


@@ -758,19 +756,20 @@ DEFUN(bfd_putb32,(data, addr),
 }
 
 void
 }
 
 void

-DEFUN(bfd_putl32,(data, addr),
-      bfd_vma data AND
-      register bfd_byte *addr)
+bfd_putl32 (data, addr)
+     bfd_vma data;
+     register bfd_byte *addr;

 {
         addr[0] = (bfd_byte)data;
         addr[1] = (bfd_byte)(data >>  8);
         addr[2] = (bfd_byte)(data >> 16);
         addr[3] = (bfd_byte)(data >> 24);
 }
 {
         addr[0] = (bfd_byte)data;
         addr[1] = (bfd_byte)(data >>  8);
         addr[2] = (bfd_byte)(data >> 16);
         addr[3] = (bfd_byte)(data >> 24);
 }

+

 void
 void

-DEFUN(bfd_putb64,(data, addr),
-        bfd_vma data AND
-        register bfd_byte *addr)
+bfd_putb64 (data, addr)
+     bfd_vma data;
+     register bfd_byte *addr;

 {
 #ifdef BFD64
   addr[0] = (bfd_byte)(data >> (7*8));
 {
 #ifdef BFD64
   addr[0] = (bfd_byte)(data >> (7*8));


@@ -784,13 +783,12 @@ DEFUN(bfd_putb64,(data, addr),
 #else
   BFD_FAIL();
 #endif
 #else
   BFD_FAIL();
 #endif

-

 }
 
 void
 }
 
 void

-DEFUN(bfd_putl64,(data, addr),
-      bfd_vma data AND
-      register bfd_byte *addr)
+bfd_putl64 (data, addr)
+     bfd_vma data;
+     register bfd_byte *addr;

 {
 #ifdef BFD64
   addr[7] = (bfd_byte)(data >> (7*8));
 {
 #ifdef BFD64
   addr[7] = (bfd_byte)(data >> (7*8));


@@ -804,19 +802,17 @@ DEFUN(bfd_putl64,(data, addr),
 #else
   BFD_FAIL();
 #endif
 #else
   BFD_FAIL();
 #endif

-

 }
 }

-

 \f
 /* Default implementation */
 
 boolean
 \f
 /* Default implementation */
 
 boolean

-DEFUN(bfd_generic_get_section_contents, (abfd, section, location, offset, count),
-      bfd *abfd AND
-      sec_ptr section AND
-      PTR location AND
-      file_ptr offset AND
-      bfd_size_type count)
+_bfd_generic_get_section_contents (abfd, section, location, offset, count)
+     bfd *abfd;
+     sec_ptr section;
+     PTR location;
+     file_ptr offset;
+     bfd_size_type count;

 {
     if (count == 0)
         return true;
 {
     if (count == 0)
         return true;


@@ -832,7 +828,7 @@ DEFUN(bfd_generic_get_section_contents, (abfd, section, location, offset, count)
    in read-write files, though.  See other set_section_contents functions
    to see why it doesn't work for new sections.  */
 boolean
    in read-write files, though.  See other set_section_contents functions
    to see why it doesn't work for new sections.  */
 boolean

-bfd_generic_set_section_contents (abfd, section, location, offset, count)
+_bfd_generic_set_section_contents (abfd, section, location, offset, count)

      bfd *abfd;
      sec_ptr section;
      PTR location;
      bfd *abfd;
      sec_ptr section;
      PTR location;


@@ -842,12 +838,6 @@ bfd_generic_set_section_contents (abfd, section, location, offset, count)
   if (count == 0)
     return true;
 
   if (count == 0)
     return true;
 

-  if (offset + count > bfd_get_section_size_after_reloc (section))
-    {
-      bfd_error = bad_value;
-      return false;
-    }
-

   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) == -1
       || bfd_write (location, (bfd_size_type) 1, count, abfd) != count)
     return false;
   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) == -1
       || bfd_write (location, (bfd_size_type) 1, count, abfd) != count)
     return false;


@@ -876,3 +866,14 @@ bfd_log2(x)
     result++;
   return result;
 }
     result++;
   return result;
 }

+
+boolean
+bfd_generic_is_local_label (abfd, sym)
+     bfd *abfd;
+     asymbol *sym;
+{
+  char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
+
+  return (sym->name[0] == locals_prefix);
+}
+