* libbfd.c (bfd_malloc, bfd_realloc): New functions.

	(bfd_zmalloc): Return PTR, not char *.  Take size_t, not
	bfd_size_type.
	* libbfd-in.h (bfd_malloc, bfd_realloc): Declare.
	(bfd_zmalloc): Change declaration.
	* libbfd.h: Rebuild.
	* Many files: Use bfd_malloc and bfd_realloc rather than malloc
	and realloc.  Don't set bfd_error_no_memory if they fail.

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 60624ef12c85833eb09bc8573018b073caf836db..ba3565a0242974481a77822ca11a12138caadd58 100644 (file)
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,14 @@
+Fri Dec  1 14:46:51 1995  Ian Lance Taylor  <ian@cygnus.com>
+
+       * libbfd.c (bfd_malloc, bfd_realloc): New functions.
+       (bfd_zmalloc): Return PTR, not char *.  Take size_t, not
+       bfd_size_type.
+       * libbfd-in.h (bfd_malloc, bfd_realloc): Declare.
+       (bfd_zmalloc): Change declaration.
+       * libbfd.h: Rebuild.
+       * Many files: Use bfd_malloc and bfd_realloc rather than malloc
+       and realloc.  Don't set bfd_error_no_memory if they fail.
+
 Thu Nov 30 19:32:26 1995  Kim Knuttila  <krk@cygnus.com>
 
        * coff-ppc.c: Added macros to tidy up toc cell treatment. Numerous

diff --git a/bfd/aoutx.h b/bfd/aoutx.h
index 91ee8d833f4227bfb1e4d43632b868bebeab6737..81ad6ca1cffc0a821840c0d2720b5e8b5988936b 100644 (file)
--- a/bfd/aoutx.h
+++ b/bfd/aoutx.h
@@ -1240,12 +1240,9 @@ aout_get_external_symbols (abfd)
         later on.  If we put them on the obstack it might not be
         possible to free them.  */
       syms = ((struct external_nlist *)
-             malloc ((size_t) count * EXTERNAL_NLIST_SIZE));
+             bfd_malloc ((size_t) count * EXTERNAL_NLIST_SIZE));
       if (syms == (struct external_nlist *) NULL && count != 0)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         return false;
-       }
+       return false;
 
       if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
          || (bfd_read (syms, 1, exec_hdr (abfd)->a_syms, abfd)
@@ -1280,12 +1277,9 @@ aout_get_external_symbols (abfd)
        return false;
       strings = (char *) obj_aout_string_window (abfd).data;
 #else
-      strings = (char *) malloc ((size_t) stringsize + 1);
+      strings = (char *) bfd_malloc ((size_t) stringsize + 1);
       if (strings == NULL)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         return false;
-       }
+       return false;
 
       /* Skip space for the string count in the buffer for convenience
         when using indexes.  */
@@ -1736,12 +1730,9 @@ NAME(aout,slurp_symbol_table) (abfd)
 
   cached_size = (obj_aout_external_sym_count (abfd)
                 * sizeof (aout_symbol_type));
-  cached = (aout_symbol_type *) malloc (cached_size);
+  cached = (aout_symbol_type *) bfd_malloc (cached_size);
   if (cached == NULL && cached_size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+    return false;
   if (cached_size != 0)
     memset (cached, 0, cached_size);
 
@@ -2294,19 +2285,15 @@ NAME(aout,slurp_reloc_table) (abfd, asect, symbols)
 
   count = reloc_size / each_size;
 
-  reloc_cache = (arelent *) malloc ((size_t) (count * sizeof (arelent)));
+  reloc_cache = (arelent *) bfd_malloc ((size_t) (count * sizeof (arelent)));
   if (reloc_cache == NULL && count != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+    return false;
   memset (reloc_cache, 0, count * sizeof (arelent));
 
-  relocs = malloc ((size_t) reloc_size);
+  relocs = bfd_malloc ((size_t) reloc_size);
   if (relocs == NULL && reloc_size != 0)
     {
       free (reloc_cache);
-      bfd_set_error (bfd_error_no_memory);
       return false;
     }
 
@@ -2732,12 +2719,10 @@ NAME(aout,find_nearest_line)
     adata (abfd).line_buf = buf = NULL;
   else
     {
-      adata (abfd).line_buf = buf = (char *) malloc (filelen + funclen + 2);
-      if (adata (abfd).line_buf == NULL)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         return false;
-       }
+      buf = (char *) bfd_malloc (filelen + funclen + 2);
+      adata (abfd).line_buf = buf;
+      if (buf == NULL)
+       return false;
     }
 
   if (main_file_name != NULL)
@@ -3568,20 +3553,17 @@ NAME(aout,final_link) (abfd, info, callback)
     goto error_return;
 
   /* Allocate buffers to hold section contents and relocs.  */
-  aout_info.contents = (bfd_byte *) malloc (max_contents_size);
-  aout_info.relocs = (PTR) malloc (max_relocs_size);
-  aout_info.symbol_map = (int *) malloc (max_sym_count * sizeof (int *));
+  aout_info.contents = (bfd_byte *) bfd_malloc (max_contents_size);
+  aout_info.relocs = (PTR) bfd_malloc (max_relocs_size);
+  aout_info.symbol_map = (int *) bfd_malloc (max_sym_count * sizeof (int *));
   aout_info.output_syms = ((struct external_nlist *)
-                          malloc ((max_sym_count + 1)
-                                  * sizeof (struct external_nlist)));
+                          bfd_malloc ((max_sym_count + 1)
+                                      * sizeof (struct external_nlist)));
   if ((aout_info.contents == NULL && max_contents_size != 0)
       || (aout_info.relocs == NULL && max_relocs_size != 0)
       || (aout_info.symbol_map == NULL && max_sym_count != 0)
       || aout_info.output_syms == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   /* If we have a symbol named __DYNAMIC, force it out now.  This is
      required by SunOS.  Doing this here rather than in sunos.c is a

diff --git a/bfd/bout.c b/bfd/bout.c
index a896f280b7e3098ac1fdc782940444db70975612..79218e474e1500a656ebe18f9df942b4f19401f4 100644 (file)
--- a/bfd/bout.c
+++ b/bfd/bout.c
@@ -500,16 +500,13 @@ b_out_slurp_reloc_table (abfd, asect, symbols)
     return false;
   count = reloc_size / sizeof (struct relocation_info);
 
-  relocs = (struct relocation_info *) malloc (reloc_size);
-  if (!relocs && reloc_size != 0) {
-    bfd_set_error (bfd_error_no_memory);
+  relocs = (struct relocation_info *) bfd_malloc (reloc_size);
+  if (!relocs && reloc_size != 0)
     return false;
-  }
-  reloc_cache = (arelent *) malloc ((count+1) * sizeof (arelent));
+  reloc_cache = (arelent *) bfd_malloc ((count+1) * sizeof (arelent));
   if (!reloc_cache) {
     if (relocs != NULL)
       free ((char*)relocs);
-    bfd_set_error (bfd_error_no_memory);
     return false;
   }
 
@@ -698,11 +695,9 @@ b_out_squirt_out_relocs (abfd, section)
   int extern_mask, pcrel_mask,  len_2, callj_mask;
   if (count == 0) return true;
   generic   = section->orelocation;
-  native = ((struct relocation_info *) malloc (natsize));
-  if (!native && natsize != 0) {
-    bfd_set_error (bfd_error_no_memory);
+  native = ((struct relocation_info *) bfd_malloc (natsize));
+  if (!native && natsize != 0)
     return false;
-  }
 
   if (abfd->xvec->header_byteorder_big_p)
   {
@@ -1154,12 +1149,9 @@ b_out_bfd_relax_section (abfd, i, link_info, again)
     {
       long reloc_count;
 
-      reloc_vector = (arelent **) malloc (reloc_size);
+      reloc_vector = (arelent **) bfd_malloc (reloc_size);
       if (reloc_vector == NULL && reloc_size != 0)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         goto error_return;
-       }
+       goto error_return;
 
       /* Get the relocs and think about them */
       reloc_count =
@@ -1230,12 +1222,9 @@ b_out_bfd_get_relocated_section_contents (in_abfd, link_info, link_order,
                                                       data, relocateable,
                                                       symbols);
 
-  reloc_vector = (arelent **) malloc (reloc_size);
+  reloc_vector = (arelent **) bfd_malloc (reloc_size);
   if (reloc_vector == NULL && reloc_size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   input_section->reloc_done = 1;
 

diff --git a/bfd/coff-alpha.c b/bfd/coff-alpha.c
index d24c79124e6d1bbbccf1b272869b4badb7108ea7..4ad7077fa621cde622440e06aa658ab71d3dd413 100644 (file)
--- a/bfd/coff-alpha.c
+++ b/bfd/coff-alpha.c
@@ -759,12 +759,9 @@ alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order,
 
   if (reloc_size < 0)
     goto error_return;
-  reloc_vector = (arelent **) malloc (reloc_size);
+  reloc_vector = (arelent **) bfd_malloc (reloc_size);
   if (reloc_vector == NULL && reloc_size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   if (! bfd_get_section_contents (input_bfd, input_section, data,
                                  (file_ptr) 0, input_section->_raw_size))

diff --git a/bfd/coff-i960.c b/bfd/coff-i960.c
index a67256c00b62e1bf1da9134c1fc76b0868df8b98..b3bf4e1cab490f92e03a7f1abf40c26edd94e049 100644 (file)
--- a/bfd/coff-i960.c
+++ b/bfd/coff-i960.c
@@ -287,12 +287,9 @@ coff_i960_start_final_link (abfd, info)
   if (! info->relocateable)
     return true;
 
-  esym = (bfd_byte *) malloc (symesz);
+  esym = (bfd_byte *) bfd_malloc (symesz);
   if (esym == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+    return false;
 
   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
     return false;

diff --git a/bfd/coff-mips.c b/bfd/coff-mips.c
index 591bd757ac6e45e0746dda19c813f2d56785c20e..51a5ecd8a31fd568aae7ee28fdadac9ad8c4bb9f 100644 (file)
--- a/bfd/coff-mips.c
+++ b/bfd/coff-mips.c
@@ -1996,12 +1996,9 @@ mips_relax_section (abfd, sec, info, again)
          if (info->keep_memory)
            contents = (bfd_byte *) bfd_alloc (abfd, sec->_raw_size);
          else
-           contents = (bfd_byte *) malloc ((size_t) sec->_raw_size);
+           contents = (bfd_byte *) bfd_malloc ((size_t) sec->_raw_size);
          if (contents == (bfd_byte *) NULL)
-           {
-             bfd_set_error (bfd_error_no_memory);
-             goto error_return;
-           }
+           goto error_return;
          if (! bfd_get_section_contents (abfd, sec, (PTR) contents,
                                          (file_ptr) 0, sec->_raw_size))
            goto error_return;

diff --git a/bfd/coff-ppc.c b/bfd/coff-ppc.c
index 379ef4e3406badfb0449238131016688c7ca95fb..350cca30c00f1326b94a0990d07b7ec0eca46ecd 100644 (file)
--- a/bfd/coff-ppc.c
+++ b/bfd/coff-ppc.c
@@ -824,7 +824,9 @@ record_toc(toc_section, our_toc_offset, cat, name)
 {
   /* add this entry to our toc addr-offset-name list */
   struct list_ele *t;
-  t = malloc(sizeof(struct list_ele));
+  t = bfd_malloc (sizeof (struct list_ele));
+  if (t == NULL)
+    abort ();
   t->next = 0;
   t->offset = our_toc_offset;
   t->name = name;

diff --git a/bfd/coff-sh.c b/bfd/coff-sh.c
index a57a3531cccca76d73ccc9921a1c74ae33f71df4..5d987b60a85baf7b931e540c2f5e6ddc7962ce84 100644 (file)
--- a/bfd/coff-sh.c
+++ b/bfd/coff-sh.c
@@ -482,12 +482,9 @@ sh_relax_section (abfd, sec, link_info, again)
            contents = coff_section_data (abfd, sec)->contents;
          else
            {
-             contents = (bfd_byte *) malloc (sec->_raw_size);
+             contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
              if (contents == NULL)
-               {
-                 bfd_set_error (bfd_error_no_memory);
-                 goto error_return;
-               }
+               goto error_return;
              free_contents = contents;
 
              if (! bfd_get_section_contents (abfd, sec, contents,
@@ -1087,12 +1084,9 @@ sh_relax_delete_bytes (abfd, sec, addr, count)
                          Perhaps, if info->keep_memory is false, we
                          should free them, if we are permitted to,
                          when we leave sh_coff_relax_section.  */
-                     ocontents = (bfd_byte *) malloc (o->_raw_size);
+                     ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
                      if (ocontents == NULL)
-                       {
-                         bfd_set_error (bfd_error_no_memory);
-                         return false;
-                       }
+                       return false;
                      if (! bfd_get_section_contents (abfd, o, ocontents,
                                                      (file_ptr) 0,
                                                      o->_raw_size))
@@ -1383,21 +1377,15 @@ sh_coff_get_relocated_section_contents (output_bfd, link_info, link_order,
        goto error_return;
 
       internal_syms = ((struct internal_syment *)
-                      malloc (obj_raw_syment_count (input_bfd)
-                              * sizeof (struct internal_syment)));
+                      bfd_malloc (obj_raw_syment_count (input_bfd)
+                                  * sizeof (struct internal_syment)));
       if (internal_syms == NULL)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         goto error_return;
-       }
+       goto error_return;
 
-      sections = (asection **) malloc (obj_raw_syment_count (input_bfd)
-                                      * sizeof (asection *));
+      sections = (asection **) bfd_malloc (obj_raw_syment_count (input_bfd)
+                                          * sizeof (asection *));
       if (sections == NULL)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         goto error_return;
-       }
+       goto error_return;
 
       isymp = internal_syms;
       secpp = sections;

diff --git a/bfd/coffgen.c b/bfd/coffgen.c
index 14c0e3856c4a6a74f8ed897dd0f085840e9b830a..7ad5b6f4c09274dd4bd2ece49789beea135e0a3d 100644 (file)
--- a/bfd/coffgen.c
+++ b/bfd/coffgen.c
@@ -397,12 +397,9 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
 
   if (external_relocs == NULL)
     {
-      free_external = (bfd_byte *) malloc (sec->reloc_count * relsz);
+      free_external = (bfd_byte *) bfd_malloc (sec->reloc_count * relsz);
       if (free_external == NULL && sec->reloc_count > 0)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         goto error_return;
-       }
+       goto error_return;
       external_relocs = free_external;
     }
 
@@ -414,13 +411,10 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
   if (internal_relocs == NULL)
     {
       free_internal = ((struct internal_reloc *)
-                      malloc (sec->reloc_count
-                              * sizeof (struct internal_reloc)));
+                      bfd_malloc (sec->reloc_count
+                                  * sizeof (struct internal_reloc)));
       if (free_internal == NULL && sec->reloc_count > 0)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         goto error_return;
-       }
+       goto error_return;
       internal_relocs = free_internal;
     }
 
@@ -1456,12 +1450,9 @@ _bfd_coff_get_external_symbols (abfd)
 
   size = obj_raw_syment_count (abfd) * symesz;
 
-  syms = (PTR) malloc (size);
+  syms = (PTR) bfd_malloc (size);
   if (syms == NULL && size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+    return false;
 
   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
       || bfd_read (syms, size, 1, abfd) != size)
@@ -1523,12 +1514,9 @@ _bfd_coff_read_string_table (abfd)
       return NULL;
     }
 
-  strings = (char *) malloc (strsize);
+  strings = (char *) bfd_malloc (strsize);
   if (strings == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return NULL;
-    }
+    return NULL;
 
   if (bfd_read (strings + STRING_SIZE_SIZE,
                strsize - STRING_SIZE_SIZE, 1, abfd)

diff --git a/bfd/ecoff.c b/bfd/ecoff.c
index fbc6028a4ef8607bea9e5c0a080ed787161ae197..5c04b1b8d8ff16de10840459c6b3ca5f756b7a46 100644 (file)
--- a/bfd/ecoff.c
+++ b/bfd/ecoff.c
@@ -465,12 +465,9 @@ ecoff_slurp_symbolic_header (abfd)
     }
 
   /* Read the symbolic information header.  */
-  raw = (PTR) malloc ((size_t) external_hdr_size);
+  raw = (PTR) bfd_malloc ((size_t) external_hdr_size);
   if (raw == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) == -1
       || (bfd_read (raw, external_hdr_size, 1, abfd)
@@ -2063,13 +2060,10 @@ ecoff_compute_section_file_positions (abfd)
   sofar = _bfd_ecoff_sizeof_headers (abfd, false);
 
   /* Sort the sections by VMA.  */
-  sorted_hdrs = (asection **) malloc (abfd->section_count
-                                     * sizeof (asection *));
+  sorted_hdrs = (asection **) bfd_malloc (abfd->section_count
+                                         * sizeof (asection *));
   if (sorted_hdrs == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+    return false;
   for (current = abfd->sections, i = 0;
        current != NULL;
        current = current->next, i++)
@@ -2479,12 +2473,9 @@ _bfd_ecoff_write_object_contents (abfd)
       siz = filhsz;
     if (siz < aoutsz)
       siz = aoutsz;
-    buff = (PTR) malloc ((size_t) siz);
+    buff = (PTR) bfd_malloc ((size_t) siz);
     if (buff == NULL)
-      {
-       bfd_set_error (bfd_error_no_memory);
-       goto error_return;
-      }
+      goto error_return;
   }
 
   internal_f.f_nscns = 0;
@@ -3598,23 +3589,17 @@ ecoff_link_check_archive_element (abfd, info, pneeded)
   /* Read in the external symbols and external strings.  */
   external_ext_size = backend->debug_swap.external_ext_size;
   esize = symhdr->iextMax * external_ext_size;
-  external_ext = (PTR) malloc (esize);
+  external_ext = (PTR) bfd_malloc (esize);
   if (external_ext == NULL && esize != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
       || bfd_read (external_ext, 1, esize, abfd) != esize)
     goto error_return;
 
-  ssext = (char *) malloc (symhdr->issExtMax);
+  ssext = (char *) bfd_malloc (symhdr->issExtMax);
   if (ssext == NULL && symhdr->issExtMax != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
       || (bfd_read (ssext, 1, symhdr->issExtMax, abfd) !=
@@ -3724,23 +3709,17 @@ ecoff_link_add_object_symbols (abfd, info)
   /* Read in the external symbols and external strings.  */
   external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size;
   esize = symhdr->iextMax * external_ext_size;
-  external_ext = (PTR) malloc (esize);
+  external_ext = (PTR) bfd_malloc (esize);
   if (external_ext == NULL && esize != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
       || bfd_read (external_ext, 1, esize, abfd) != esize)
     goto error_return;
 
-  ssext = (char *) malloc (symhdr->issExtMax);
+  ssext = (char *) bfd_malloc (symhdr->issExtMax);
   if (ssext == NULL && symhdr->issExtMax != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
       || (bfd_read (ssext, 1, symhdr->issExtMax, abfd)
@@ -4209,10 +4188,9 @@ ecoff_final_link_debug_accumulate (output_bfd, input_bfd, info, handle)
     debug->ptr = NULL;                                                 \
   else                                                                 \
     {                                                                  \
-      debug->ptr = (type) malloc ((size_t) (size * symhdr->count));    \
+      debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count));        \
       if (debug->ptr == NULL)                                          \
        {                                                               \
-          bfd_set_error (bfd_error_no_memory);                         \
           ret = false;                                                 \
           goto return_something;                                       \
        }                                                               \
@@ -4453,14 +4431,11 @@ ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
 
   /* Get the section contents.  We allocate memory for the larger of
      the size before relocating and the size after relocating.  */
-  contents = (bfd_byte *) malloc (raw_size >= cooked_size
-                                 ? (size_t) raw_size
-                                 : (size_t) cooked_size);
+  contents = (bfd_byte *) bfd_malloc (raw_size >= cooked_size
+                                     ? (size_t) raw_size
+                                     : (size_t) cooked_size);
   if (contents == NULL && raw_size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   /* If we are relaxing, the contents may have already been read into
      memory, in which case we copy them into our new buffer.  We don't
@@ -4486,12 +4461,9 @@ ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
     external_relocs = section_tdata->external_relocs;
   else
     {
-      external_relocs = (PTR) malloc ((size_t) external_relocs_size);
+      external_relocs = (PTR) bfd_malloc ((size_t) external_relocs_size);
       if (external_relocs == NULL && external_relocs_size != 0)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         goto error_return;
-       }
+       goto error_return;
 
       if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
          || (bfd_read (external_relocs, 1, external_relocs_size, input_bfd)
@@ -4728,12 +4700,9 @@ ecoff_reloc_link_order (output_bfd, info, output_section, link_order)
 
   /* Get some memory and swap out the reloc.  */
   external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
-  rbuf = (bfd_byte *) malloc ((size_t) external_reloc_size);
+  rbuf = (bfd_byte *) bfd_malloc ((size_t) external_reloc_size);
   if (rbuf == (bfd_byte *) NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+    return false;
 
   (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (PTR) rbuf);
 

diff --git a/bfd/ecofflink.c b/bfd/ecofflink.c
index b8b0631ade1d5cf7c9579576e69608467f3e2619..af84d205565d650192b1c2df77db1c3bfcd39057 100644 (file)
--- a/bfd/ecofflink.c
+++ b/bfd/ecofflink.c
@@ -270,15 +270,9 @@ ecoff_add_bytes (buf, bufend, need)
       if (want < ALLOC_SIZE)
        want = ALLOC_SIZE;
     }
-  if (*buf == NULL)
-    newbuf = (char *) malloc (have + want);
-  else
-    newbuf = (char *) realloc (*buf, have + want);
+  newbuf = (char *) bfd_realloc (*buf, have + want);
   if (newbuf == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+    return false;
   *buf = newbuf;
   *bufend = *buf + have + want;
   return true;
@@ -503,12 +497,9 @@ bfd_ecoff_debug_init (output_bfd, output_debug, output_swap, info)
 {
   struct accumulate *ainfo;
 
-  ainfo = (struct accumulate *) malloc (sizeof (struct accumulate));
+  ainfo = (struct accumulate *) bfd_malloc (sizeof (struct accumulate));
   if (!ainfo)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return NULL;
-    }
+    return NULL;
   if (! bfd_hash_table_init_n (&ainfo->fdr_hash.table, string_hash_newfunc,
                               1021))
     return NULL;
@@ -720,12 +711,9 @@ bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap,
             information that should not be merged.  */
          name = input_debug->ss + fdr.issBase + fdr.rss;
 
-         lookup = (char *) malloc (strlen (name) + 20);
+         lookup = (char *) bfd_malloc (strlen (name) + 20);
          if (lookup == NULL)
-           {
-             bfd_set_error (bfd_error_no_memory);
-             return false;
-           }
+           return false;
          sprintf (lookup, "%s %lx", name, fdr.csym);
 
          fh = string_hash_lookup (&ainfo->fdr_hash, lookup, true, true);
@@ -1558,12 +1546,9 @@ ecoff_write_symhdr (abfd, debug, swap, where)
   SET (cbExtOffset, iextMax, swap->external_ext_size);
 #undef SET
 
-  buff = (PTR) malloc ((size_t) swap->external_hdr_size);
+  buff = (PTR) bfd_malloc ((size_t) swap->external_hdr_size);
   if (buff == NULL && swap->external_hdr_size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   (*swap->swap_hdr_out) (abfd, symhdr, buff);
   if (bfd_write (buff, 1, swap->external_hdr_size, abfd)
@@ -1660,12 +1645,9 @@ ecoff_write_shuffle (abfd, swap, shuffle, space)
       bfd_byte *s;
 
       i = swap->debug_align - (total & (swap->debug_align - 1));
-      s = (bfd_byte *) malloc (i);
+      s = (bfd_byte *) bfd_malloc (i);
       if (s == NULL && i != 0)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         return false;
-       }
+       return false;
 
       memset ((PTR) s, 0, i);
       if (bfd_write ((PTR) s, 1, i, abfd) != i)
@@ -1697,12 +1679,9 @@ bfd_ecoff_write_accumulated_debug (handle, abfd, debug, swap, info, where)
   if (! ecoff_write_symhdr (abfd, debug, swap, where))
     goto error_return;
 
-  space = (PTR) malloc (ainfo->largest_file_shuffle);
+  space = (PTR) bfd_malloc (ainfo->largest_file_shuffle);
   if (space == NULL && ainfo->largest_file_shuffle != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   if (! ecoff_write_shuffle (abfd, swap, ainfo->line, space)
       || ! ecoff_write_shuffle (abfd, swap, ainfo->pdr, space)
@@ -1749,12 +1728,9 @@ bfd_ecoff_write_accumulated_debug (handle, abfd, debug, swap, info, where)
          bfd_byte *s;
 
          i = swap->debug_align - (total & (swap->debug_align - 1));
-         s = (bfd_byte *) malloc (i);
+         s = (bfd_byte *) bfd_malloc (i);
          if (s == NULL && i != 0)
-           {
-             bfd_set_error (bfd_error_no_memory);
-             goto error_return;
-           }
+           goto error_return;
          memset ((PTR) s, 0, i);
          if (bfd_write ((PTR) s, 1, i, abfd) != i)
            {
@@ -1777,12 +1753,9 @@ bfd_ecoff_write_accumulated_debug (handle, abfd, debug, swap, info, where)
 
       i = (swap->debug_align
           - (debug->symbolic_header.issExtMax & (swap->debug_align - 1)));
-      s = (bfd_byte *) malloc (i);
+      s = (bfd_byte *) bfd_malloc (i);
       if (s == NULL && i != 0)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         goto error_return;
-       }
+       goto error_return;
       memset ((PTR) s, 0, i);
       if (bfd_write ((PTR) s, 1, i, abfd) != i)
        {
@@ -2352,12 +2325,9 @@ _bfd_ecoff_locate_line (abfd, section, offset, debug_info, debug_swap,
        {
          if (line_info->find_buffer != NULL)
            free (line_info->find_buffer);
-         buffer = (char *) malloc (len);
+         buffer = (char *) bfd_malloc (len);
          if (buffer == NULL)
-           {
-             bfd_set_error (bfd_error_no_memory);
-             return false;
-           }
+           return false;
          line_info->find_buffer = buffer;
        }
 

diff --git a/bfd/elf.c b/bfd/elf.c
index 424372ce2c52365a1d17f641f3c47bca2a25125e..87eaa943595d4268f95ea39eb0455abf6167c371 100644 (file)
--- a/bfd/elf.c
+++ b/bfd/elf.c
@@ -1158,12 +1158,9 @@ assign_section_numbers (abfd)
              char *alc;
 
              len = strlen (sec->name);
-             alc = (char *) malloc (len - 2);
+             alc = (char *) bfd_malloc (len - 2);
              if (alc == NULL)
-               {
-                 bfd_set_error (bfd_error_no_memory);
-                 return false;
-               }
+               return false;
              strncpy (alc, sec->name, len - 3);
              alc[len - 3] = '\0';
              s = bfd_get_section_by_name (abfd, alc);
@@ -1548,13 +1545,10 @@ map_sections_to_segments (abfd)
 
   /* Select the allocated sections, and sort them.  */
 
-  sections = (asection **) malloc (bfd_count_sections (abfd)
-                                  * sizeof (asection *));
+  sections = (asection **) bfd_malloc (bfd_count_sections (abfd)
+                                      * sizeof (asection *));
   if (sections == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   i = 0;
   for (s = abfd->sections; s != NULL; s = s->next)

diff --git a/bfd/elfcode.h b/bfd/elfcode.h
index 0b28608d012f759f1891c6964f8f6d1ee487ef29..2e35f902cf569f850994bbcd40fb28b6690e0970 100644 (file)
--- a/bfd/elfcode.h
+++ b/bfd/elfcode.h
@@ -891,12 +891,9 @@ elf_slurp_symbol_table (abfd, symptrs, dynamic)
 
       /* Temporarily allocate room for the raw ELF symbols.  */
       x_symp = ((Elf_External_Sym *)
-               malloc (symcount * sizeof (Elf_External_Sym)));
+               bfd_malloc (symcount * sizeof (Elf_External_Sym)));
       if (x_symp == NULL && symcount != 0)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         goto error_return;
-       }
+       goto error_return;
 
       if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd)
          != symcount * sizeof (Elf_External_Sym))
@@ -1053,12 +1050,9 @@ elf_slurp_reloc_table (abfd, asect, symbols)
              && (asect->reloc_count
                  == d->rel_hdr.sh_size / d->rel_hdr.sh_entsize));
 
-  allocated = (PTR) malloc ((size_t) d->rel_hdr.sh_size);
+  allocated = (PTR) bfd_malloc ((size_t) d->rel_hdr.sh_size);
   if (allocated == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0
       || (bfd_read (allocated, 1, d->rel_hdr.sh_size, abfd)

diff --git a/bfd/elfcore.h b/bfd/elfcore.h
index 7e4403d78d2aed8e10dbf2e53db1e6a46c2eecb0..e505759886d34d6c06bd8f6342ae3cf3f4cf380b 100644 (file)
--- a/bfd/elfcore.h
+++ b/bfd/elfcore.h
@@ -238,7 +238,7 @@ elf_corefile_note (abfd, hdr)
   asection *newsect;
 
   if (hdr->p_filesz > 0
-      && (buf = (char *) malloc ((size_t) hdr->p_filesz)) != NULL
+      && (buf = (char *) bfd_malloc ((size_t) hdr->p_filesz)) != NULL
       && bfd_seek (abfd, hdr->p_offset, SEEK_SET) != -1
       && bfd_read ((PTR) buf, hdr->p_filesz, 1, abfd) == hdr->p_filesz)
     {
@@ -296,7 +296,6 @@ elf_corefile_note (abfd, hdr)
     }
   else if (hdr->p_filesz > 0)
     {
-      bfd_set_error (bfd_error_no_memory);
       return false;
     }
   return true;

diff --git a/bfd/elflink.h b/bfd/elflink.h
index cdf3afb4b00bc3972ef781a82bceb9fd707a55fa..3e182956f7b46ed03d8aedbf892df0f88b13e514 100644 (file)
--- a/bfd/elflink.h
+++ b/bfd/elflink.h
@@ -110,13 +110,10 @@ elf_link_add_archive_symbols (abfd, info)
   c = bfd_ardata (abfd)->symdef_count;
   if (c == 0)
     return true;
-  defined = (boolean *) malloc (c * sizeof (boolean));
-  included = (boolean *) malloc (c * sizeof (boolean));
+  defined = (boolean *) bfd_malloc (c * sizeof (boolean));
+  included = (boolean *) bfd_malloc (c * sizeof (boolean));
   if (defined == (boolean *) NULL || included == (boolean *) NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
   memset (defined, 0, c * sizeof (boolean));
   memset (included, 0, c * sizeof (boolean));
 
@@ -328,12 +325,10 @@ elf_link_add_object_symbols (abfd, info)
       extsymoff = hdr->sh_info;
     }
 
-  buf = (Elf_External_Sym *) malloc (extsymcount * sizeof (Elf_External_Sym));
+  buf = ((Elf_External_Sym *)
+        bfd_malloc (extsymcount * sizeof (Elf_External_Sym)));
   if (buf == NULL && extsymcount != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   /* We store a pointer to the hash table entry for each external
      symbol.  */
@@ -404,12 +399,9 @@ elf_link_add_object_symbols (abfd, info)
          int elfsec;
          unsigned long link;
 
-         dynbuf = (Elf_External_Dyn *) malloc ((size_t) s->_raw_size);
+         dynbuf = (Elf_External_Dyn *) bfd_malloc ((size_t) s->_raw_size);
          if (dynbuf == NULL)
-           {
-             bfd_set_error (bfd_error_no_memory);
-             goto error_return;
-           }
+           goto error_return;
 
          if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf,
                                          (file_ptr) 0, s->_raw_size))
@@ -1090,15 +1082,9 @@ elf_add_dynamic_entry (info, tag, val)
   BFD_ASSERT (s != NULL);
 
   newsize = s->_raw_size + sizeof (Elf_External_Dyn);
-  if (s->contents == NULL)
-    newcontents = (bfd_byte *) malloc (newsize);
-  else
-    newcontents = (bfd_byte *) realloc (s->contents, newsize);
+  newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
   if (newcontents == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+    return false;
 
   dyn.d_tag = tag;
   dyn.d_un.d_val = val;
@@ -1146,22 +1132,16 @@ elf_link_read_relocs (abfd, o, external_relocs, internal_relocs, keep_memory)
       if (keep_memory)
        internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
       else
-       internal_relocs = alloc2 = (Elf_Internal_Rela *) malloc (size);
+       internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
       if (internal_relocs == NULL)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         goto error_return;
-       }
+       goto error_return;
     }
 
   if (external_relocs == NULL)
     {
-      alloc1 = (PTR) malloc ((size_t) rel_hdr->sh_size);
+      alloc1 = (PTR) bfd_malloc ((size_t) rel_hdr->sh_size);
       if (alloc1 == NULL)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         goto error_return;
-       }
+       goto error_return;
       external_relocs = alloc1;
     }
 
@@ -1847,13 +1827,10 @@ elf_bfd_final_link (abfd, info)
            goto error_return;
 
          p = ((struct elf_link_hash_entry **)
-              malloc (o->reloc_count
-                      * sizeof (struct elf_link_hash_entry *)));
+              bfd_malloc (o->reloc_count
+                          * sizeof (struct elf_link_hash_entry *)));
          if (p == NULL && o->reloc_count != 0)
-           {
-             bfd_set_error (bfd_error_no_memory);
-             goto error_return;
-           }
+           goto error_return;
          elf_section_data (o)->rel_hashes = p;
          pend = p + o->reloc_count;
          for (; p < pend; p++)
@@ -1898,12 +1875,9 @@ elf_bfd_final_link (abfd, info)
   else
     finfo.symbuf_size = max_sym_count;
   finfo.symbuf = ((Elf_External_Sym *)
-                 malloc (finfo.symbuf_size * sizeof (Elf_External_Sym)));
+                 bfd_malloc (finfo.symbuf_size * sizeof (Elf_External_Sym)));
   if (finfo.symbuf == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   /* Start writing out the symbol table.  The first symbol is always a
      dummy symbol.  */
@@ -1954,17 +1928,20 @@ elf_bfd_final_link (abfd, info)
 
   /* Allocate some memory to hold information read in from the input
      files.  */
-  finfo.contents = (bfd_byte *) malloc (max_contents_size);
-  finfo.external_relocs = (PTR) malloc (max_external_reloc_size);
+  finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
+  finfo.external_relocs = (PTR) bfd_malloc (max_external_reloc_size);
   finfo.internal_relocs = ((Elf_Internal_Rela *)
-                          malloc (max_internal_reloc_count
-                                  * sizeof (Elf_Internal_Rela)));
+                          bfd_malloc (max_internal_reloc_count
+                                      * sizeof (Elf_Internal_Rela)));
   finfo.external_syms = ((Elf_External_Sym *)
-                        malloc (max_sym_count * sizeof (Elf_External_Sym)));
+                        bfd_malloc (max_sym_count
+                                    * sizeof (Elf_External_Sym)));
   finfo.internal_syms = ((Elf_Internal_Sym *)
-                        malloc (max_sym_count * sizeof (Elf_Internal_Sym)));
-  finfo.indices = (long *) malloc (max_sym_count * sizeof (long));
-  finfo.sections = (asection **) malloc (max_sym_count * sizeof (asection *));
+                        bfd_malloc (max_sym_count
+                                    * sizeof (Elf_Internal_Sym)));
+  finfo.indices = (long *) bfd_malloc (max_sym_count * sizeof (long));
+  finfo.sections = ((asection **)
+                   bfd_malloc (max_sym_count * sizeof (asection *)));
   if ((finfo.contents == NULL && max_contents_size != 0)
       || (finfo.external_relocs == NULL && max_external_reloc_size != 0)
       || (finfo.internal_relocs == NULL && max_internal_reloc_count != 0)
@@ -1972,10 +1949,7 @@ elf_bfd_final_link (abfd, info)
       || (finfo.internal_syms == NULL && max_sym_count != 0)
       || (finfo.indices == NULL && max_sym_count != 0)
       || (finfo.sections == NULL && max_sym_count != 0))
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   /* Since ELF permits relocations to be against local symbols, we
      must have the local symbols available when we do the relocations.

diff --git a/bfd/i386lynx.c b/bfd/i386lynx.c
index 6b27bd19ed317124b7c063543114a62fd142e1a1..089c7a7cda63b51897fa5f26cf176ab82ea6f86b 100644 (file)
--- a/bfd/i386lynx.c
+++ b/bfd/i386lynx.c
@@ -418,12 +418,9 @@ doit:
   count = reloc_size / each_size;
 
 
-  reloc_cache = (arelent *) malloc (count * sizeof (arelent));
+  reloc_cache = (arelent *) bfd_malloc (count * sizeof (arelent));
   if (!reloc_cache && count != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+    return false;
   memset (reloc_cache, 0, count * sizeof (arelent));
 
   relocs = (PTR) bfd_alloc (abfd, reloc_size);

diff --git a/bfd/ieee.c b/bfd/ieee.c
index 6348f6ee3b8e2fbedf4aa7488f1edfff396dabb7..87120298af31a4feed5360a757474506770cee42 100644 (file)
--- a/bfd/ieee.c
+++ b/bfd/ieee.c
@@ -3158,10 +3158,7 @@ ieee_make_empty_symbol (abfd)
   ieee_symbol_type *new =
   (ieee_symbol_type *) bfd_zmalloc (sizeof (ieee_symbol_type));
   if (!new)
-    {
-      bfd_set_error (bfd_error_no_error);
-      return NULL;
-    }
+    return NULL;
   new->symbol.the_bfd = abfd;
   return &new->symbol;
 }

diff --git a/bfd/peicode.h b/bfd/peicode.h
index 79c427eceb8d0db58eec8d65854b1e2bf45c0279..8b669424f07ab44da8bdc8446542ca2bef7190c0 100644 (file)
--- a/bfd/peicode.h
+++ b/bfd/peicode.h
@@ -1160,13 +1160,10 @@ pe_print_idata(abfd, vfile)
 
       bfd_byte *data = 0;
       int offset;
-      data = (bfd_byte *) malloc ((size_t) bfd_section_size (abfd, 
-                                                            rel_section));
+      data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd, 
+                                                                rel_section));
       if (data == NULL && bfd_section_size (abfd, rel_section) != 0)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         return false;
-       }
+       return false;
       datasize = bfd_section_size (abfd, rel_section);
   
       bfd_get_section_contents (abfd, 
@@ -1204,13 +1201,10 @@ pe_print_idata(abfd, vfile)
   if (bfd_section_size (abfd, section) == 0)
     return true;
 
-  data = (bfd_byte *) malloc ((size_t) bfd_section_size (abfd, section));
+  data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd, section));
   datasize = bfd_section_size (abfd, section);
   if (data == NULL && datasize != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+    return false;
 
   bfd_get_section_contents (abfd, 
                            section, 
@@ -1363,13 +1357,10 @@ pe_print_pdata(abfd, vfile)
   if (bfd_section_size (abfd, section) == 0)
     return true;
 
-  data = (bfd_byte *) malloc ((size_t) bfd_section_size (abfd, section));
+  data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd, section));
   datasize = bfd_section_size (abfd, section);
   if (data == NULL && datasize != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+    return false;
 
   bfd_get_section_contents (abfd, 
                            section, 

diff --git a/bfd/som.c b/bfd/som.c
index 827c7fb02f84421586b33776bcf8ce4f056f81b8..3cc39799dd691c780baa2b156f94aee1f4d6d889 100644 (file)
--- a/bfd/som.c
+++ b/bfd/som.c
@@ -1724,12 +1724,9 @@ setup_sections (abfd, file_hdr)
 
   /* First, read in space names */
 
-  space_strings = malloc (file_hdr->space_strings_size);
+  space_strings = bfd_malloc (file_hdr->space_strings_size);
   if (!space_strings && file_hdr->space_strings_size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   if (bfd_seek (abfd, file_hdr->space_strings_location, SEEK_SET) < 0)
     goto error_return;
@@ -1939,8 +1936,8 @@ setup_sections (abfd, file_hdr)
     }
   /* Now that we've read in all the subspace records, we need to assign
      a target index to each subspace.  */
-  subspace_sections = (asection **) malloc (total_subspaces
-                                           * sizeof (asection *));
+  subspace_sections = (asection **) bfd_malloc (total_subspaces
+                                               * sizeof (asection *));
   if (subspace_sections == NULL)
     goto error_return;
 
@@ -3708,12 +3705,9 @@ som_build_and_write_symbol_table (abfd)
   /* Compute total symbol table size and allocate a chunk of memory
      to hold the symbol table as we build it.  */
   symtab_size = num_syms * sizeof (struct symbol_dictionary_record);
-  som_symtab = (struct symbol_dictionary_record *) malloc (symtab_size);
+  som_symtab = (struct symbol_dictionary_record *) bfd_malloc (symtab_size);
   if (som_symtab == NULL && symtab_size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
   memset (som_symtab, 0, symtab_size);
 
   /* Walk over each symbol.  */
@@ -3797,12 +3791,9 @@ som_slurp_string_table (abfd)
     }
 
   /* Allocate and read in the string table.  */
-  stringtab = malloc (obj_som_stringtab_size (abfd));
+  stringtab = bfd_malloc (obj_som_stringtab_size (abfd));
   if (stringtab == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+    return false;
   memset (stringtab, 0, obj_som_stringtab_size (abfd));
 
   if (bfd_seek (abfd, obj_som_str_filepos (abfd), SEEK_SET) < 0)
@@ -3904,22 +3895,16 @@ som_slurp_symbol_table (abfd)
 
   stringtab = obj_som_stringtab (abfd);
 
-  symbase = (som_symbol_type *)
-    malloc (symbol_count * sizeof (som_symbol_type));
+  symbase = ((som_symbol_type *)
+            bfd_malloc (symbol_count * sizeof (som_symbol_type)));
   if (symbase == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
   memset (symbase, 0, symbol_count * sizeof (som_symbol_type));
 
   /* Read in the external SOM representation.  */
-  buf = malloc (symbol_count * symsize);
+  buf = bfd_malloc (symbol_count * symsize);
   if (buf == NULL && symbol_count * symsize != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
   if (bfd_seek (abfd, obj_som_sym_filepos (abfd), SEEK_SET) < 0)
     goto error_return;
   if (bfd_read (buf, symbol_count * symsize, 1, abfd) 
@@ -4453,7 +4438,7 @@ som_set_reloc_info (fixup, end, internal_relocs, section, symbols, just_count)
                      /* Got to read the damn contents first.  We don't
                         bother saving the contents (yet).  Add it one
                         day if the need arises.  */
-                     section->contents = malloc (section->_raw_size);
+                     section->contents = bfd_malloc (section->_raw_size);
                      if (section->contents == NULL)
                        return -1;
 
@@ -4519,12 +4504,9 @@ som_slurp_reloc_table (abfd, section, symbols, just_count)
      parsed.  We must do so now to know how many relocations exist.  */
   if (section->reloc_count == -1)
     {
-      external_relocs = (char *) malloc (fixup_stream_size);
+      external_relocs = (char *) bfd_malloc (fixup_stream_size);
       if (external_relocs == (char *) NULL)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         return false;
-       }
+       return false;
       /* Read in the external forms. */
       if (bfd_seek (abfd,
                    obj_som_reloc_filepos (abfd) + section->rel_filepos,
@@ -5000,12 +4982,10 @@ som_bfd_count_ar_symbols (abfd, lst_header, count)
   file_ptr lst_filepos = bfd_tell (abfd) - sizeof (struct lst_header);
 
   hash_table = 
-    (unsigned int *) malloc (lst_header->hash_size * sizeof (unsigned int));
+    (unsigned int *) bfd_malloc (lst_header->hash_size
+                                * sizeof (unsigned int));
   if (hash_table == NULL && lst_header->hash_size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   /* Don't forget to initialize the counter!  */
   *count = 0;
@@ -5080,21 +5060,16 @@ som_bfd_fill_in_ar_symbols (abfd, lst_header, syms)
   file_ptr lst_filepos = bfd_tell (abfd) - sizeof (struct lst_header);
 
   hash_table = 
-    (unsigned int *) malloc (lst_header->hash_size * sizeof (unsigned int));
+    (unsigned int *) bfd_malloc (lst_header->hash_size
+                                * sizeof (unsigned int));
   if (hash_table == NULL && lst_header->hash_size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   som_dict =
-    (struct som_entry *) malloc (lst_header->module_count
-                                * sizeof (struct som_entry));
+    (struct som_entry *) bfd_malloc (lst_header->module_count
+                                    * sizeof (struct som_entry));
   if (som_dict == NULL && lst_header->module_count != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   /* Read in the hash table.  The has table is an array of 32bit file offsets
      which point to the hash chains.  */
@@ -5435,29 +5410,20 @@ som_bfd_ar_write_symbol_stuff (abfd, nsyms, string_size, lst)
   unsigned int maxname = abfd->xvec->ar_max_namelen;
 
   hash_table =
-    (unsigned int *) malloc (lst.hash_size * sizeof (unsigned int));
+    (unsigned int *) bfd_malloc (lst.hash_size * sizeof (unsigned int));
   if (hash_table == NULL && lst.hash_size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
   som_dict =
-    (struct som_entry *) malloc (lst.module_count
-                                * sizeof (struct som_entry));
+    (struct som_entry *) bfd_malloc (lst.module_count
+                                    * sizeof (struct som_entry));
   if (som_dict == NULL && lst.module_count != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   last_hash_entry =
     ((struct lst_symbol_record **)
-     malloc (lst.hash_size * sizeof (struct lst_symbol_record *)));
+     bfd_malloc (lst.hash_size * sizeof (struct lst_symbol_record *)));
   if (last_hash_entry == NULL && lst.hash_size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   /* Lots of fields are file positions relative to the start
      of the lst record.  So save its location.  */
@@ -5504,18 +5470,12 @@ som_bfd_ar_write_symbol_stuff (abfd, nsyms, string_size, lst)
   curr_som_offset = (curr_som_offset + 0x1) & ~0x1;
 
   /* FIXME should be done with buffers just like everything else... */
-  lst_syms = malloc (nsyms * sizeof (struct lst_symbol_record));
+  lst_syms = bfd_malloc (nsyms * sizeof (struct lst_symbol_record));
   if (lst_syms == NULL && nsyms != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
-  strings = malloc (string_size);
+    goto error_return;
+  strings = bfd_malloc (string_size);
   if (strings == NULL && string_size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   p = strings;
   curr_lst_sym = lst_syms;

diff --git a/bfd/srec.c b/bfd/srec.c
index 4b8fa4b4a5d72d01257ec5d143b08e1450cef1c4..466a85b47d24281b1de3546835e4c47cbb340e7e 100644 (file)
--- a/bfd/srec.c
+++ b/bfd/srec.c
@@ -461,12 +461,9 @@ srec_scan (abfd)
              {
                if (buf != NULL)
                  free (buf);
-               buf = (bfd_byte *) malloc (bytes * 2);
+               buf = (bfd_byte *) bfd_malloc (bytes * 2);
                if (buf == NULL)
-                 {
-                   bfd_set_error (bfd_error_no_memory);
-                   goto error_return;
-                 }
+                 goto error_return;
                bufsize = bytes * 2;
              }
 
@@ -667,12 +664,9 @@ srec_read_section (abfd, section, contents)
        {
          if (buf != NULL)
            free (buf);
-         buf = (bfd_byte *) malloc (bytes * 2);
+         buf = (bfd_byte *) bfd_malloc (bytes * 2);
          if (buf == NULL)
-           {
-             bfd_set_error (bfd_error_no_memory);
-             goto error_return;
-           }
+           goto error_return;
          bufsize = bytes * 2;
        }
 

diff --git a/bfd/sunos.c b/bfd/sunos.c
index ffd4fdc0f5a2fdb4e95793289b634f78021379a9..25b9072c3066b0e5a75871efe3bd14eeb1ef7fd8 100644 (file)
--- a/bfd/sunos.c
+++ b/bfd/sunos.c
@@ -350,7 +350,7 @@ sunos_canonicalize_dynamic_symtab (abfd, storage)
     if (info->dyninfo.ld_buckets > info->dynsym_count)
       abort ();
     table_size = info->dyninfo.ld_stab - info->dyninfo.ld_hash;
-    table = (bfd_byte *) malloc (table_size);
+    table = (bfd_byte *) bfd_malloc (table_size);
     if (table == NULL && table_size != 0)
       abort ();
     if (bfd_seek (abfd, info->dyninfo.ld_hash, SEEK_SET) != 0
@@ -1311,13 +1311,10 @@ bfd_sunos_size_dynamic_sections (output_bfd, info, sdynptr, sneedptr,
       bfd_byte *contents;
 
       add = 8 - (s->_raw_size & 7);
-      contents = (bfd_byte *) realloc (s->contents,
-                                      (size_t) (s->_raw_size + add));
+      contents = (bfd_byte *) bfd_realloc (s->contents,
+                                          (size_t) (s->_raw_size + add));
       if (contents == NULL)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         return false;
-       }
+       return false;
       memset (contents + s->_raw_size, 0, (size_t) add);
       s->contents = contents;
       s->_raw_size += add;
@@ -1389,7 +1386,7 @@ sunos_scan_relocs (info, abfd, sec, rel_size)
     return true;
 
   if (! info->keep_memory)
-    relocs = free_relocs = malloc ((size_t) rel_size);
+    relocs = free_relocs = bfd_malloc ((size_t) rel_size);
   else
     {
       struct aout_section_data_struct *n;
@@ -1401,15 +1398,12 @@ sunos_scan_relocs (info, abfd, sec, rel_size)
       else
        {
          set_aout_section_data (sec, n);
-         relocs = malloc ((size_t) rel_size);
+         relocs = bfd_malloc ((size_t) rel_size);
          aout_section_data (sec)->relocs = relocs;
        }
     }
   if (relocs == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+    return false;
 
   if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
       || bfd_read (relocs, 1, rel_size, abfd) != rel_size)
@@ -1942,16 +1936,10 @@ sunos_scan_dynamic_symbol (h, data)
         There are no debugging symbols in the dynamic symbols.  */
       s = bfd_get_section_by_name (dynobj, ".dynstr");
       BFD_ASSERT (s != NULL);
-      if (s->contents == NULL)
-       contents = (bfd_byte *) malloc (len + 1);
-      else
-       contents = (bfd_byte *) realloc (s->contents,
-                                        (size_t) (s->_raw_size + len + 1));
+      contents = (bfd_byte *) bfd_realloc (s->contents,
+                                          s->_raw_size + len + 1);
       if (contents == NULL)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         return false;
-       }
+       return false;
       s->contents = contents;
 
       h->dynstr_index = s->_raw_size;

diff --git a/bfd/xcofflink.c b/bfd/xcofflink.c
index b12d42734e88ab6f9516f48806a273fc4aaf48bb..4936c3c254f91315fc19ebf01e48ce358772892f 100644 (file)
--- a/bfd/xcofflink.c
+++ b/bfd/xcofflink.c
@@ -1058,13 +1058,10 @@ xcoff_link_add_symbols (abfd, info)
      scanning along the relocs as we process the csects.  We index
      into reloc_info using the section target_index.  */
   reloc_info = ((struct reloc_info_struct *)
-               malloc ((abfd->section_count + 1)
-                       * sizeof (struct reloc_info_struct)));
+               bfd_malloc ((abfd->section_count + 1)
+                           * sizeof (struct reloc_info_struct)));
   if (reloc_info == NULL)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
   memset ((PTR) reloc_info, 0,
          (abfd->section_count + 1) * sizeof (struct reloc_info_struct));
 
@@ -1080,12 +1077,9 @@ xcoff_link_add_symbols (abfd, info)
            xcoff_read_internal_relocs (abfd, o, true, (bfd_byte *) NULL,
                                        false, (struct internal_reloc *) NULL);
          reloc_info[o->target_index].csects =
-           (asection **) malloc (o->reloc_count * sizeof (asection *));
+           (asection **) bfd_malloc (o->reloc_count * sizeof (asection *));
          if (reloc_info[o->target_index].csects == NULL)
-           {
-             bfd_set_error (bfd_error_no_memory);
-             goto error_return;
-           }
+           goto error_return;
          memset (reloc_info[o->target_index].csects, 0,
                  o->reloc_count * sizeof (asection *));
        }
@@ -1095,12 +1089,9 @@ xcoff_link_add_symbols (abfd, info)
        {
          bfd_byte *linenos;
 
-         linenos = (bfd_byte *) malloc (o->lineno_count * linesz);
+         linenos = (bfd_byte *) bfd_malloc (o->lineno_count * linesz);
          if (linenos == NULL)
-           {
-             bfd_set_error (bfd_error_no_memory);
-             goto error_return;
-           }
+           goto error_return;
          reloc_info[o->target_index].linenos = linenos;
          if (bfd_seek (abfd, o->line_filepos, SEEK_SET) != 0
              || (bfd_read (linenos, linesz, o->lineno_count, abfd)
@@ -1943,12 +1934,9 @@ xcoff_link_add_dynamic_symbols (abfd, info)
       goto error_return;
     }
 
-  buf = (bfd_byte *) malloc (lsec->_raw_size);
+  buf = (bfd_byte *) bfd_malloc (lsec->_raw_size);
   if (buf == NULL && lsec->_raw_size > 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   if (! bfd_get_section_contents (abfd, lsec, (PTR) buf, (file_ptr) 0,
                                  lsec->_raw_size))
@@ -2441,12 +2429,9 @@ bfd_xcoff_export_symbol (output_bfd, info, harg, syscall)
       char *fnname;
       struct xcoff_link_hash_entry *hfn;
 
-      fnname = (char *) malloc (strlen (h->root.root.string) + 2);
+      fnname = (char *) bfd_malloc (strlen (h->root.root.string) + 2);
       if (fnname == NULL)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         return false;
-       }
+       return false;
       fnname[0] = '.';
       strcpy (fnname + 1, h->root.root.string);
       hfn = xcoff_link_hash_lookup (xcoff_hash_table (info),
@@ -2838,12 +2823,9 @@ bfd_xcoff_size_dynamic_sections (output_bfd, info, libpath, entry,
         bfd_alloc, because I expect that, when linking many files
         together, many of the strings will be the same.  Storing the
         strings in the hash table should save space in this case.  */
-      debug_contents = (bfd_byte *) malloc (subdeb->_raw_size);
+      debug_contents = (bfd_byte *) bfd_malloc (subdeb->_raw_size);
       if (debug_contents == NULL)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         goto error_return;
-       }
+       goto error_return;
       if (! bfd_get_section_contents (sub, subdeb, (PTR) debug_contents,
                                      (file_ptr) 0, subdeb->_raw_size))
        goto error_return;
@@ -3106,15 +3088,11 @@ xcoff_build_ldsyms (h, p)
          while (ldinfo->string_size + len + 3 > newalc)
            newalc *= 2;
 
-         if (ldinfo->strings == NULL)
-           newstrings = (bfd_byte *) malloc (newalc);
-         else
-           newstrings = ((bfd_byte *)
-                         realloc ((PTR) ldinfo->strings, newalc));
+         newstrings = ((bfd_byte *)
+                       bfd_realloc ((PTR) ldinfo->strings, newalc));
          if (newstrings == NULL)
            {
              ldinfo->failed = true;
-             bfd_set_error (bfd_error_no_memory);
              return false;
            }
          ldinfo->string_alc = newalc;
@@ -3334,14 +3312,12 @@ _bfd_xcoff_bfd_final_link (abfd, info)
 
     /* We use section_count + 1, rather than section_count, because
        the target_index fields are 1 based.  */
-    finfo.section_info = ((struct xcoff_link_section_info *)
-                         malloc ((abfd->section_count + 1)
-                                 * sizeof (struct xcoff_link_section_info)));
+    finfo.section_info =
+      ((struct xcoff_link_section_info *)
+       bfd_malloc ((abfd->section_count + 1)
+                  * sizeof (struct xcoff_link_section_info)));
     if (finfo.section_info == NULL)
-      {
-       bfd_set_error (bfd_error_no_memory);
-       goto error_return;
-      }
+      goto error_return;
     for (i = 0; i <= abfd->section_count; i++)
       {
        finfo.section_info[i].relocs = NULL;
@@ -3379,17 +3355,14 @@ _bfd_xcoff_bfd_final_link (abfd, info)
             would be slow.  */
          finfo.section_info[o->target_index].relocs =
            ((struct internal_reloc *)
-            malloc (o->reloc_count * sizeof (struct internal_reloc)));
+            bfd_malloc (o->reloc_count * sizeof (struct internal_reloc)));
          finfo.section_info[o->target_index].rel_hashes =
            ((struct xcoff_link_hash_entry **)
-            malloc (o->reloc_count
+            bfd_malloc (o->reloc_count
                     * sizeof (struct xcoff_link_hash_entry *)));
          if (finfo.section_info[o->target_index].relocs == NULL
              || finfo.section_info[o->target_index].rel_hashes == NULL)
-           {
-             bfd_set_error (bfd_error_no_memory);
-             goto error_return;
-           }
+           goto error_return;
 
          if (o->reloc_count > max_output_reloc_count)
            max_output_reloc_count = o->reloc_count;
@@ -3436,25 +3409,22 @@ _bfd_xcoff_bfd_final_link (abfd, info)
 
   /* Allocate some buffers used while linking.  */
   finfo.internal_syms = ((struct internal_syment *)
-                        malloc (max_sym_count
-                                * sizeof (struct internal_syment)));
-  finfo.sym_indices = (long *) malloc (max_sym_count * sizeof (long));
+                        bfd_malloc (max_sym_count
+                                    * sizeof (struct internal_syment)));
+  finfo.sym_indices = (long *) bfd_malloc (max_sym_count * sizeof (long));
   finfo.outsyms = ((bfd_byte *)
-                  malloc ((size_t) ((max_sym_count + 1) * symesz)));
-  finfo.linenos = (bfd_byte *) malloc (max_lineno_count
-                                      * bfd_coff_linesz (abfd));
-  finfo.contents = (bfd_byte *) malloc (max_contents_size);
-  finfo.external_relocs = (bfd_byte *) malloc (max_reloc_count * relsz);
+                  bfd_malloc ((size_t) ((max_sym_count + 1) * symesz)));
+  finfo.linenos = (bfd_byte *) bfd_malloc (max_lineno_count
+                                          * bfd_coff_linesz (abfd));
+  finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
+  finfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
   if ((finfo.internal_syms == NULL && max_sym_count > 0)
       || (finfo.sym_indices == NULL && max_sym_count > 0)
       || finfo.outsyms == NULL
       || (finfo.linenos == NULL && max_lineno_count > 0)
       || (finfo.contents == NULL && max_contents_size > 0)
       || (finfo.external_relocs == NULL && max_reloc_count > 0))
-    {
-      bfd_set_error (bfd_error_no_memory);
-      goto error_return;
-    }
+    goto error_return;
 
   obj_raw_syment_count (abfd) = 0;
   xcoff_data (abfd)->toc = (bfd_vma) -1;