* opncls.c (_bfd_new_bfd, _bfd_new_bfd_contained_in): Add

	"_bfd_" to function names.
	* archive.c (_bfd_create_empty_archive_element_shell),
	libbfd-in.h: Change callers.

	* libbfd.c (bfd_zmalloc): Renamed from zalloc.
	* libbfd.c (bfd_add_to_string_table),
	trad-core.c (trad_unix_core_file_p),
	targets.c (bfd_target_list),
	ptrace-core.c (ptrace_unix_core_file_p),
	opncls.c (new_bfd), libbfd-in.h,
	ieee.c (ieee_make_empty_symbol),
	elf32-hppa.c (hppa_elf_stub_branch_reloc),
	(hppa_elf_stub_reloc): Change callers.
	* libbfd.h: Regenerated.

	* archive.c (_bfd_look_for_bfd_in_cache): Add "_bfd_" to name.
	(_bfd_get_elt_at_filepos),
	coff-rs6000.c (rs6000coff_get_elt_at_filepos), libbfd-in.h:
	Change callers.

	* format.c (bfd_check_format_matches), libbfd-in.h, targets.c,
	elfcode.h (elf_object_p): Rename target_vector to bfd_target_vector
	and default_vector to bfd_default_vector.
	* libbfd.h: Regenerated.

1 files changed, 129 insertions, 139 deletions

diff --git a/bfd/libbfd.c b/bfd/libbfd.c
index 8e20e3e..5a120b1 100644
--- a/bfd/libbfd.c
+++ b/bfd/libbfd.c
@@ -1,5 +1,5 @@
 /* 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.
@@ -34,65 +34,65 @@ DESCRIPTION
 
 /*ARGSUSED*/
 boolean
-DEFUN(_bfd_dummy_new_section_hook,(ignore, ignore_newsect),
-      bfd *ignore AND
-      asection *ignore_newsect)
+_bfd_dummy_new_section_hook (ignore, ignore_newsect)
+     bfd *ignore;
+     asection *ignore_newsect;
 {
   return true;
 }
 
 /*ARGSUSED*/
 boolean
-DEFUN(bfd_false ,(ignore),
-      bfd *ignore)
+bfd_false (ignore)
+     bfd *ignore;
 {
   return false;
 }
 
 /*ARGSUSED*/
 boolean
-DEFUN(bfd_true,(ignore),
-      bfd *ignore)
+bfd_true (ignore)
+     bfd *ignore;
 {
   return true;
 }
 
 /*ARGSUSED*/
 PTR
-DEFUN(bfd_nullvoidptr,(ignore),
-      bfd *ignore)
+bfd_nullvoidptr (ignore)
+     bfd *ignore;
 {
   return (PTR)NULL;
 }
 
 /*ARGSUSED*/
 int 
-DEFUN(bfd_0,(ignore),
-      bfd *ignore)
+bfd_0 (ignore)
+     bfd *ignore;
 {
   return 0;
 }
 
 /*ARGSUSED*/
 unsigned int 
-DEFUN(bfd_0u,(ignore),
-      bfd *ignore)
+bfd_0u (ignore)
+     bfd *ignore;
 {
    return 0;
 }
 
 /*ARGSUSED*/
 void 
-DEFUN(bfd_void,(ignore),
-      bfd *ignore)
+bfd_void (ignore)
+     bfd *ignore;
 {
 }
 
 /*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_dummy_core_file_matches_executable_p (ignore_core_bfd, ignore_exec_bfd)
+     bfd *ignore_core_bfd;
+     bfd *ignore_exec_bfd;
 {
   bfd_error = invalid_operation;
   return false;
@@ -102,35 +102,35 @@ DEFUN(_bfd_dummy_core_file_matches_executable_p,(ignore_core_bfd, ignore_exec_bf
 
 /*ARGSUSED*/
 char *
-DEFUN(_bfd_dummy_core_file_failing_command,(ignore_abfd),
-      bfd *ignore_abfd)
+_bfd_dummy_core_file_failing_command (ignore_abfd)
+     bfd *ignore_abfd;
 {
   return (char *)NULL;
 }
 
 /*ARGSUSED*/
 int
-DEFUN(_bfd_dummy_core_file_failing_signal,(ignore_abfd),
-     bfd *ignore_abfd)
+_bfd_dummy_core_file_failing_signal (ignore_abfd)
+     bfd *ignore_abfd;
 {
   return 0;
 }
 
 /*ARGSUSED*/
 bfd_target *
-DEFUN(_bfd_dummy_target,(ignore_abfd),
-     bfd *ignore_abfd)
+_bfd_dummy_target (ignore_abfd)
+     bfd *ignore_abfd;
 {
   return 0;
 }
 
-/** zalloc -- allocate and clear storage */
 
+#ifndef bfd_zmalloc
+/* allocate and clear storage */
 
-#ifndef zalloc
 char *
-DEFUN(zalloc,(size),
-      bfd_size_type size)
+bfd_zmalloc (size)
+     bfd_size_type size;
 {
   char *ptr = (char *) malloc ((size_t)size);
 
@@ -139,7 +139,7 @@ DEFUN(zalloc,(size),
 
   return ptr;
 }
-#endif
+#endif /* bfd_zmalloc */
 
 /*
 INTERNAL_FUNCTION
@@ -158,8 +158,9 @@ DESCRIPTION
   However, obstack routines can't do this ... */
 
 
-DEFUN(PTR bfd_xmalloc,(size),
-      bfd_size_type size)
+PTR
+bfd_xmalloc (size)
+     bfd_size_type size;
 {
   static CONST char no_memory_message[] = "Virtual memory exhausted!\n";
   PTR ptr;
@@ -185,8 +186,8 @@ DESCRIPTION
 	Uses <<size_t>>, so it's suitable for use as <<obstack_chunk_alloc>>.
  */
 PTR
-DEFUN(bfd_xmalloc_by_size_t, (size),
-      size_t size)
+bfd_xmalloc_by_size_t (size)
+     size_t size;
 {
   return bfd_xmalloc ((bfd_size_type) size);
 }
@@ -202,20 +203,22 @@ DEFUN(bfd_xmalloc_by_size_t, (size),
    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);
 }
+
 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));
@@ -263,9 +266,9 @@ DESCRIPTION
 
 */
 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);
@@ -273,8 +276,8 @@ DEFUN(bfd_write_bigendian_4byte_int,(abfd, i),
 }
 
 long
-DEFUN(bfd_tell,(abfd),
-      bfd *abfd)
+bfd_tell (abfd)
+     bfd *abfd;
 {
   file_ptr ptr;
 
@@ -287,25 +290,25 @@ DEFUN(bfd_tell,(abfd),
 }
 
 int
-DEFUN(bfd_flush,(abfd),
-      bfd *abfd)
+bfd_flush (abfd)
+     bfd *abfd;
 {
   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);
 }
 
 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;
@@ -388,11 +391,11 @@ DEFUN(bfd_seek,(abfd, position, direction),
    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;
@@ -401,10 +404,10 @@ 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
-       take it next time */
+       take it next time).  */
     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) {
       bfd_error = no_memory;
@@ -569,86 +572,86 @@ DESCRIPTION
   (((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
-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
-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
-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
-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
-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)
-     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)
-        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)
-     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)
-        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
-DEFUN(bfd_getb64,(addr),
-      register bfd_byte *addr)
+bfd_getb64 (addr)
+     register const bfd_byte *addr;
 {
 #ifdef BFD64
   bfd_vma low, high;
@@ -668,14 +671,12 @@ DEFUN(bfd_getb64,(addr),
   BFD_FAIL();
   return 0;
 #endif
-
 }
 
 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) |
@@ -697,8 +698,8 @@ DEFUN(bfd_getl64,(addr),
 }
 
 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;
@@ -718,14 +719,12 @@ DEFUN(bfd_getb_signed_64,(addr),
   BFD_FAIL();
   return 0;
 #endif
-
 }
 
 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) |
@@ -743,13 +742,12 @@ DEFUN(bfd_getl_signed_64,(addr),
   BFD_FAIL();
   return 0;
 #endif
-
 }
 
 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);
@@ -758,19 +756,20 @@ DEFUN(bfd_putb32,(data, addr),
 }
 
 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);
 }
+
 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));
@@ -784,13 +783,12 @@ DEFUN(bfd_putb64,(data, addr),
 #else
   BFD_FAIL();
 #endif
-
 }
 
 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));
@@ -804,19 +802,17 @@ DEFUN(bfd_putl64,(data, addr),
 #else
   BFD_FAIL();
 #endif
-
 }
-
 
 /* 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;
@@ -842,12 +838,6 @@ bfd_generic_set_section_contents (abfd, section, location, offset, count)
   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;