Replace bfd_alloc/bfd_malloc + memset with bfd_zalloc/bfd_zmalloc

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 148731404f15b896754998032c8e1e9a8823f232..a98068e859c3ba05746dc2776c915a66b0c071fb 100644 (file)
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,40 @@
+2002-06-07  Alan Modra  <amodra@bigpond.net.au>
+
+       * aoutx.h (NAME(aout,slurp_symbol_table)): Use bfd_zmalloc.
+       (NAME(aout,slurp_reloc_table)): Likewise.
+       * coff-mips.c (mips_relax_section): Use bfd_zalloc.
+       * coff-rs6000.c (xcoff_write_armap_big): Use bfd_zmalloc.
+       (xcoff_write_archive_contents_big): Likewise.
+       (xcoff_generate_rtinit): Likewise.
+       (xcoff_generate_rtinit): Likewise, and check error return.
+       * coff64-rs6000.c (xcoff64_generate_rtinit): Likewise.
+       * coffgen.c (coff_section_symbol): Use bfd_zalloc.
+       (coff_get_normalized_symtab): Likewise.
+       (coff_make_empty_symbol): Likewise.
+       (bfd_coff_set_symbol_class): Likewise.
+       * cofflink.c (coff_link_add_symbols): Likewise.
+       * ecoff.c (_bfd_ecoff_make_empty_symbol): Likewise.
+       * ecofflink.c (ecoff_write_shuffle): Use bfd_zmalloc.
+       (bfd_ecoff_write_accumulated_debug): Likewise.
+       * elf64-alpha.c (get_got_entry): Use bfd_zalloc.
+       * i386linux.c (bfd_i386linux_size_dynamic_sections): Likewise.
+       * i386lynx.c (NAME(lynx,slurp_reloc_table)): Use bfd_zmalloc.
+       * ieee.c (do_with_relocs): Use bfd_zalloc.
+       * m68klinux.c (bfd_m68klinux_size_dynamic_sections): Likewise.
+       * pdp11.c (NAME(aout,slurp_symbol_table)): Use bfd_zmalloc.
+       (NAME(aout,slurp_reloc_table)): Likewise.
+       (NAME(aout,squirt_out_relocs)): Don't memset when zalloc'd.
+       * reloc16.c (bfd_coff_reloc16_relax_section): Use bfd_zmalloc.
+       * som.c (som_build_and_write_symbol_table): Likewise.
+       (som_slurp_string_table): Likewise.
+       (som_slurp_symbol_table): Likewise.
+       (som_bfd_ar_write_symbol_stuff): Likewise.
+       * sparclinux.c (bfd_sparclinux_size_dynamic_sections): Use bfd_zalloc.
+       * sunos.c (bfd_sunos_size_dynamic_sections): Likewise.
+       * tekhex.c (find_chunk): Likewise.  Get rid of unused "sname".
+       * vms-gsd.c (_bfd_vms_slurp_gsd): Use bfd_zmalloc.
+       * xcofflink.c (xcoff_link_add_symbols): Use bfd_zalloc/bfd_zmalloc.
+
 2002-06-07  Alan Modra  <amodra@bigpond.net.au>
 
        * elf-bfd.h (struct bfd_elf_section_data <group_name>): Replace with
@@ -476,9 +513,9 @@
 
        * elf32-arm.h (bfd_elf32_arm_get_bfd_for_interworking): Don't add glue
        sections only record bfd.
-       (bfd_elf32_arm_add_glue_sections_to_bfd): New function. 
+       (bfd_elf32_arm_add_glue_sections_to_bfd): New function.
        * bfd-in.h (bfd_elf32_arm_add_glue_sections_to_bfd): Declare it.
-       * bfd-in2.h: Regenerate.          
+       * bfd-in2.h: Regenerate.
 
 2002-05-28  Nick Clifton  <nickc@cambridge.redhat.com>
 

diff --git a/bfd/aoutx.h b/bfd/aoutx.h
index 3c9cd4fafc8978ba96dee229c98002cf32e78e1f..c2448f4a5756ebf08a935fb8dcec78536576b695 100644 (file)
--- a/bfd/aoutx.h
+++ b/bfd/aoutx.h
@@ -1837,11 +1837,9 @@ NAME(aout,slurp_symbol_table) (abfd)
 
   cached_size = obj_aout_external_sym_count (abfd);
   cached_size *= sizeof (aout_symbol_type);
-  cached = (aout_symbol_type *) bfd_malloc (cached_size);
+  cached = (aout_symbol_type *) bfd_zmalloc (cached_size);
   if (cached == NULL && cached_size != 0)
     return false;
-  if (cached_size != 0)
-    memset (cached, 0, (size_t) cached_size);
 
   /* Convert from external symbol information to internal.  */
   if (! (NAME(aout,translate_symbol_table)
@@ -2411,10 +2409,9 @@ NAME(aout,slurp_reloc_table) (abfd, asect, symbols)
   count = reloc_size / each_size;
 
   amt = count * sizeof (arelent);
-  reloc_cache = (arelent *) bfd_malloc (amt);
+  reloc_cache = (arelent *) bfd_zmalloc (amt);
   if (reloc_cache == NULL && count != 0)
     return false;
-  memset (reloc_cache, 0, (size_t) amt);
 
   relocs = bfd_malloc (reloc_size);
   if (relocs == NULL && reloc_size != 0)

diff --git a/bfd/coff-mips.c b/bfd/coff-mips.c
index 1e4ead4c3fd2d55768977e0a90ea25cddd23182a..edccd5cbbee78105d980d2b83703e918bf278aa4 100644 (file)
--- a/bfd/coff-mips.c
+++ b/bfd/coff-mips.c
@@ -2116,10 +2116,9 @@ mips_relax_section (abfd, sec, info, again)
          bfd_size_type size;
 
          size = (bfd_size_type) sec->reloc_count * sizeof (long);
-         offsets = (long *) bfd_alloc (abfd, size);
+         offsets = (long *) bfd_zalloc (abfd, size);
          if (offsets == (long *) NULL)
            goto error_return;
-         memset (offsets, 0, (size_t) size);
          section_tdata->offsets = offsets;
        }
 

diff --git a/bfd/coff-rs6000.c b/bfd/coff-rs6000.c
index fdf3162bb7c9ca48263fcae009efdcdceee7484d..7cd26b88ffd4797d1fef60ca0721e418ec9f717e 100644 (file)
--- a/bfd/coff-rs6000.c
+++ b/bfd/coff-rs6000.c
@@ -1839,10 +1839,9 @@ xcoff_write_armap_big (abfd, elength, map, orl_count, stridx)
        + str_32 + (str_32 & 1);
 
       symbol_table = NULL;
-      symbol_table = (bfd_byte *) bfd_malloc (symbol_table_size);
+      symbol_table = (bfd_byte *) bfd_zmalloc (symbol_table_size);
       if (symbol_table == NULL)
        return false;
-      memset (symbol_table, 0, symbol_table_size);
 
       hdr = (struct xcoff_ar_hdr_big *) symbol_table;
        
@@ -1943,10 +1942,9 @@ xcoff_write_armap_big (abfd, elength, map, orl_count, stridx)
        + str_64 + (str_64 & 1);
 
       symbol_table = NULL;
-      symbol_table = (bfd_byte *) bfd_malloc (symbol_table_size);
+      symbol_table = (bfd_byte *) bfd_zmalloc (symbol_table_size);
       if (symbol_table == NULL)
        return false;
-      memset (symbol_table, 0, symbol_table_size);
 
       hdr = (struct xcoff_ar_hdr_big *) symbol_table;
 
@@ -2457,10 +2455,9 @@ xcoff_write_archive_contents_big (abfd)
 
   member_table_size += member_table_size & 1;
   member_table = NULL;
-  member_table = (bfd_byte *) bfd_malloc (member_table_size);
+  member_table = (bfd_byte *) bfd_zmalloc (member_table_size);
   if (member_table == NULL)
     return false;
-  memset (member_table, 0, member_table_size);
 
   hdr = (struct xcoff_ar_hdr_big *) member_table;
 
@@ -3719,11 +3716,9 @@ xcoff_generate_rtinit  (abfd, init, fini, rtld)
   data_buffer_size = 0x0040 + initsz + finisz;
   data_buffer_size += (data_buffer_size & 7) ? 8 - (data_buffer_size & 7) : 0;
   data_buffer = NULL;
-  data_buffer = (bfd_byte *) bfd_malloc (data_buffer_size);
+  data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size);
   if (data_buffer == NULL)
     return false;
-  
-  memset (data_buffer, 0, data_buffer_size);
 
   if (initsz) 
     {
@@ -3757,8 +3752,10 @@ xcoff_generate_rtinit  (abfd, init, fini, rtld)
   if (string_table_size)
     {
       string_table_size += 4;
-      string_table = (bfd_byte *)bfd_malloc (string_table_size);
-      memset (string_table, 0, string_table_size);
+      string_table = (bfd_byte *) bfd_zmalloc (string_table_size);
+      if (string_table_size == NULL)
+       return false;
+
       val = string_table_size;
       bfd_h_put_32 (abfd, val, &string_table[0]);
       st_tmp = string_table + 4;

diff --git a/bfd/coff64-rs6000.c b/bfd/coff64-rs6000.c
index 16b63d4f8ab5fafd48261a8cab0c60d759a27c2a..c7fe5ac5e73a1cb8c651fe0405cf5736d7c28c9b 100644 (file)
--- a/bfd/coff64-rs6000.c
+++ b/bfd/coff64-rs6000.c
@@ -2264,12 +2264,10 @@ xcoff64_generate_rtinit (abfd, init, fini, rtld)
   data_buffer_size = 0x0058 + initsz + finisz;
   data_buffer_size += (data_buffer_size & 7) ? 8 - (data_buffer_size & 7) : 0;
   data_buffer = NULL;
-  data_buffer = (bfd_byte *)bfd_malloc (data_buffer_size);
+  data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size);
   if (data_buffer == NULL)
     return false;
 
-  memset (data_buffer, 0, data_buffer_size);
-
   if (initsz)
     {
       val = 0x18;
@@ -2302,8 +2300,10 @@ xcoff64_generate_rtinit (abfd, init, fini, rtld)
   if (true == rtld)
     string_table_size += strlen (rtld_name) + 1;
 
-  string_table = (bfd_byte *)bfd_malloc (string_table_size);
-  memset (string_table, 0, string_table_size);
+  string_table = (bfd_byte *) bfd_zmalloc (string_table_size);
+  if (string_table == NULL)
+    return false;
+
   val = string_table_size;
   bfd_put_32 (abfd, val, &string_table[0]);
   st_tmp = string_table + 4;

diff --git a/bfd/coffgen.c b/bfd/coffgen.c
index 88591f1499ddacebba67a08f0c4fb4e2200afd24..71179fbb55284411e01ec87636507d9150a0ee90 100644 (file)
--- a/bfd/coffgen.c
+++ b/bfd/coffgen.c
@@ -1,6 +1,6 @@
 /* Support for the generic parts of COFF, for BFD.
    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000, 2001
+   2000, 2001, 2002
    Free Software Foundation, Inc.
    Written by Cygnus Support.
 
@@ -1438,13 +1438,13 @@ coff_section_symbol (abfd, name)
          combined_entry_type e[10];
        };
       struct foo *f;
-      f = (struct foo *) bfd_alloc (abfd, (bfd_size_type) sizeof (*f));
+
+      f = (struct foo *) bfd_zalloc (abfd, (bfd_size_type) sizeof (*f));
       if (!f)
        {
          bfd_set_error (bfd_error_no_error);
          return NULL;
        }
-      memset ((char *) f, 0, sizeof (*f));
       coff_symbol_from (abfd, sym)->native = csym = f->e;
     }
   csym[0].u.syment.n_sclass = C_STAT;
@@ -1835,10 +1835,9 @@ coff_get_normalized_symtab (abfd)
                if (internal_ptr->u.syment._n._n_name[i] == '\0')
                  break;
 
-             newstring = (PTR) bfd_alloc (abfd, (bfd_size_type) (i + 1));
+             newstring = (PTR) bfd_zalloc (abfd, (bfd_size_type) (i + 1));
              if (newstring == NULL)
                return (NULL);
-             memset (newstring, 0, i + 1);
              strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
              internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring;
              internal_ptr->u.syment._n._n_n._n_zeroes = 0;
@@ -1897,10 +1896,9 @@ coff_make_empty_symbol (abfd)
      bfd *abfd;
 {
   bfd_size_type amt = sizeof (coff_symbol_type);
-  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, amt);
+  coff_symbol_type *new = (coff_symbol_type *) bfd_zalloc (abfd, amt);
   if (new == NULL)
     return (NULL);
-  memset (new, 0, sizeof *new);
   new->symbol.section = 0;
   new->native = 0;
   new->lineno = (alent *) NULL;
@@ -2453,12 +2451,10 @@ bfd_coff_set_symbol_class (abfd, symbol, class)
       combined_entry_type * native;
       bfd_size_type amt = sizeof (* native);
 
-      native = (combined_entry_type *) bfd_alloc (abfd, amt);
+      native = (combined_entry_type *) bfd_zalloc (abfd, amt);
       if (native == NULL)
        return false;
 
-      memset (native, 0, sizeof (* native));
-
       native->u.syment.n_type   = T_NULL;
       native->u.syment.n_sclass = class;
 

diff --git a/bfd/cofflink.c b/bfd/cofflink.c
index 1eac3c58ce800b28c8fb21f5e62f5c8724609480..32200a83a63502c6122e0826aa59d46a061e5f4a 100644 (file)
--- a/bfd/cofflink.c
+++ b/bfd/cofflink.c
@@ -342,12 +342,10 @@ coff_link_add_symbols (abfd, info)
   /* We keep a list of the linker hash table entries that correspond
      to particular symbols.  */
   amt = symcount * sizeof (struct coff_link_hash_entry *);
-  sym_hash = (struct coff_link_hash_entry **) bfd_alloc (abfd, amt);
+  sym_hash = (struct coff_link_hash_entry **) bfd_zalloc (abfd, amt);
   if (sym_hash == NULL && symcount != 0)
     goto error_return;
   obj_coff_sym_hashes (abfd) = sym_hash;
-  memset (sym_hash, 0,
-         (size_t) symcount * sizeof (struct coff_link_hash_entry *));
 
   symesz = bfd_coff_symesz (abfd);
   BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));

diff --git a/bfd/ecoff.c b/bfd/ecoff.c
index c7230f6aaf8f1ad9468097ae39c9b2d297156ca8..56165a48cf82342e2c9ec3ded6881a786052cc23 100644 (file)
--- a/bfd/ecoff.c
+++ b/bfd/ecoff.c
@@ -661,10 +661,9 @@ _bfd_ecoff_make_empty_symbol (abfd)
   ecoff_symbol_type *new;
   bfd_size_type amt = sizeof (ecoff_symbol_type);
 
-  new = (ecoff_symbol_type *) bfd_alloc (abfd, amt);
+  new = (ecoff_symbol_type *) bfd_zalloc (abfd, amt);
   if (new == (ecoff_symbol_type *) NULL)
     return (asymbol *) NULL;
-  memset ((PTR) new, 0, sizeof *new);
   new->symbol.section = (asection *) NULL;
   new->fdr = (FDR *) NULL;
   new->local = false;

diff --git a/bfd/ecofflink.c b/bfd/ecofflink.c
index 53d65441dbef4c8fc3e91c74a448d46bc063864e..8044f3ab6e6aa4bf557c30957611274967bfed49 100644 (file)
--- a/bfd/ecofflink.c
+++ b/bfd/ecofflink.c
@@ -1,5 +1,5 @@
 /* Routines to link ECOFF debugging information.
-   Copyright 1993, 1994, 1995, 1996, 1997, 2000, 2001
+   Copyright 1993, 1994, 1995, 1996, 1997, 2000, 2001, 2002
    Free Software Foundation, Inc.
    Written by Ian Lance Taylor, Cygnus Support, <ian@cygnus.com>.
 
@@ -1650,11 +1650,10 @@ ecoff_write_shuffle (abfd, swap, shuffle, space)
       bfd_byte *s;
 
       i = swap->debug_align - (total & (swap->debug_align - 1));
-      s = (bfd_byte *) bfd_malloc ((bfd_size_type) i);
+      s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i);
       if (s == NULL && i != 0)
        return false;
 
-      memset ((PTR) s, 0, i);
       if (bfd_bwrite ((PTR) s, (bfd_size_type) i, abfd) != i)
        {
          free (s);
@@ -1736,10 +1735,10 @@ 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 *) bfd_malloc ((bfd_size_type) i);
+         s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i);
          if (s == NULL && i != 0)
            goto error_return;
-         memset ((PTR) s, 0, i);
+
          if (bfd_bwrite ((PTR) s, (bfd_size_type) i, abfd) != i)
            {
              free (s);
@@ -1761,10 +1760,10 @@ 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 *) bfd_malloc ((bfd_size_type) i);
+      s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i);
       if (s == NULL && i != 0)
        goto error_return;
-      memset ((PTR) s, 0, i);
+
       if (bfd_bwrite ((PTR) s, (bfd_size_type) i, abfd) != i)
        {
          free (s);

diff --git a/bfd/elf64-alpha.c b/bfd/elf64-alpha.c
index 67ada729bb34fcf979ad82dcc43d247d8ad0dae5..a491ecad8c8c79ed51bcc09e252ec57d5b6d75d1 100644 (file)
--- a/bfd/elf64-alpha.c
+++ b/bfd/elf64-alpha.c
@@ -2974,11 +2974,10 @@ get_got_entry (abfd, h, r_type, r_symndx, r_addend)
          size *= sizeof (struct alpha_elf_got_entry *);
 
          local_got_entries
-           = (struct alpha_elf_got_entry **) bfd_alloc (abfd, size);
+           = (struct alpha_elf_got_entry **) bfd_zalloc (abfd, size);
          if (!local_got_entries)
            return NULL;
 
-         memset (local_got_entries, 0, (size_t) size);
          alpha_elf_tdata (abfd)->local_got_entries = local_got_entries;
        }
 

diff --git a/bfd/i386linux.c b/bfd/i386linux.c
index 755b456cfcd197509fdc12e63eee4dfa5d7e8775..c144822ac2a26ca1f1ca13c97140f264fad1f45e 100644 (file)
--- a/bfd/i386linux.c
+++ b/bfd/i386linux.c
@@ -597,10 +597,9 @@ bfd_i386linux_size_dynamic_sections (output_bfd, info)
     {
       s->_raw_size = linux_hash_table (info)->fixup_count + 1;
       s->_raw_size *= 8;
-      s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
+      s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
       if (s->contents == NULL)
        return false;
-      memset (s->contents, 0, (size_t) s->_raw_size);
     }
 
   return true;

diff --git a/bfd/i386lynx.c b/bfd/i386lynx.c
index f74854334b409f6de0bc05721e076797cefe2b90..fc58767a97fa43cde3419476c320241b3605d7c5 100644 (file)
--- a/bfd/i386lynx.c
+++ b/bfd/i386lynx.c
@@ -1,5 +1,5 @@
 /* BFD back-end for i386 a.out binaries under LynxOS.
-   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 2001
+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 2001, 2002
    Free Software Foundation, Inc.
 
 This file is part of BFD, the Binary File Descriptor library.
@@ -429,10 +429,9 @@ doit:
   count = reloc_size / each_size;
 
 
-  reloc_cache = (arelent *) bfd_malloc (count * sizeof (arelent));
+  reloc_cache = (arelent *) bfd_zmalloc (count * sizeof (arelent));
   if (!reloc_cache && count != 0)
     return false;
-  memset (reloc_cache, 0, (size_t) count * sizeof (arelent));
 
   relocs = (PTR) bfd_alloc (abfd, reloc_size);
   if (!relocs && reloc_size != 0)

diff --git a/bfd/ieee.c b/bfd/ieee.c
index 4e7f3a3ed7c8f51ac8d54c2701937bba883c5ad5..2433cc432d6c0e1dfc11c54385d51a40863ef21e 100644 (file)
--- a/bfd/ieee.c
+++ b/bfd/ieee.c
@@ -2398,10 +2398,9 @@ do_with_relocs (abfd, s)
       if ((PTR) stream == (PTR) NULL)
        {
          /* Outputting a section without data, fill it up */
-         stream = (unsigned char *) (bfd_alloc (abfd, s->_raw_size));
+         stream = (unsigned char *) bfd_zalloc (abfd, s->_raw_size);
          if (!stream)
            return false;
-         memset ((PTR) stream, 0, (size_t) s->_raw_size);
        }
       while (current_byte_index < s->_raw_size)
        {

diff --git a/bfd/m68klinux.c b/bfd/m68klinux.c
index 7dd0428947ee98fb783cef42220c90f120dee7f1..863a61d68f822226f3630093eb0c3ada2c19d001 100644 (file)
--- a/bfd/m68klinux.c
+++ b/bfd/m68klinux.c
@@ -601,13 +601,12 @@ bfd_m68klinux_size_dynamic_sections (output_bfd, info)
     {
       s->_raw_size = linux_hash_table (info)->fixup_count + 1;
       s->_raw_size *= 8;
-      s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
+      s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
       if (s->contents == NULL)
        {
          bfd_set_error (bfd_error_no_memory);
          return false;
        }
-      memset (s->contents, 0, (size_t) s->_raw_size);
     }
 
   return true;

diff --git a/bfd/pdp11.c b/bfd/pdp11.c
index d4fe79eba651dec89c7043cbaf51330a7f1e7260..90db56b987574cf4592367e441d4574a573329a1 100644 (file)
--- a/bfd/pdp11.c
+++ b/bfd/pdp11.c
@@ -1841,11 +1841,9 @@ NAME(aout,slurp_symbol_table) (abfd)
 
   cached_size = obj_aout_external_sym_count (abfd);
   cached_size *= sizeof (aout_symbol_type);
-  cached = (aout_symbol_type *) bfd_malloc (cached_size);
+  cached = (aout_symbol_type *) bfd_zmalloc (cached_size);
   if (cached == NULL && cached_size != 0)
     return false;
-  if (cached_size != 0)
-    memset (cached, 0, (size_t) cached_size);
 
   /* Convert from external symbol information to internal.  */
   if (! (NAME(aout,translate_symbol_table)
@@ -2255,10 +2253,9 @@ NAME(aout,slurp_reloc_table) (abfd, asect, symbols)
     count = real_count;
   }
 
-  reloc_cache = (arelent *) bfd_malloc (count * sizeof (arelent));
+  reloc_cache = (arelent *) bfd_zmalloc (count * sizeof (arelent));
   if (reloc_cache == NULL && count != 0)
     return false;
-  memset (reloc_cache, 0, (size_t) count * sizeof (arelent));
 
   cache_ptr = reloc_cache;
 
@@ -2319,8 +2316,6 @@ NAME(aout,squirt_out_relocs) (abfd, section)
   if (!native)
     return false;
 
-  memset ((PTR)native, 0, (size_t) natsize);
-
   generic = section->orelocation;
   if (generic != NULL)
     {

diff --git a/bfd/reloc16.c b/bfd/reloc16.c
index 1d69a7f25d35063ba9711fce8957f1e9efcc3e5c..1db8daf2aa4cfe3d12fd4aede12ae2d6e6d83585 100644 (file)
--- a/bfd/reloc16.c
+++ b/bfd/reloc16.c
@@ -196,8 +196,7 @@ bfd_coff_reloc16_relax_section (abfd, input_section, link_info, again)
          The last element is used as an accumlator of shrinks.  */
       amt = reloc_count + 1;
       amt *= sizeof (unsigned);
-      shrinks = (unsigned *) bfd_malloc (amt);
-      memset (shrinks, 0, (size_t) amt);
+      shrinks = (unsigned *) bfd_zmalloc (amt);
 
       /* Loop until nothing changes in this section.  */
       do {

diff --git a/bfd/som.c b/bfd/som.c
index 6bb27f7a22064eccbde0ed9ac3e3b60e72ccf291..68c561c9b368790117bd926ef6969704a721ee14 100644 (file)
--- a/bfd/som.c
+++ b/bfd/som.c
@@ -4141,10 +4141,9 @@ som_build_and_write_symbol_table (abfd)
      to hold the symbol table as we build it.  */
   symtab_size = num_syms;
   symtab_size *= sizeof (struct symbol_dictionary_record);
-  som_symtab = (struct symbol_dictionary_record *) bfd_malloc (symtab_size);
+  som_symtab = (struct symbol_dictionary_record *) bfd_zmalloc (symtab_size);
   if (som_symtab == NULL && symtab_size != 0)
     goto error_return;
-  memset (som_symtab, 0, (size_t) symtab_size);
 
   /* Walk over each symbol.  */
   for (i = 0; i < num_syms; i++)
@@ -4230,10 +4229,9 @@ som_slurp_string_table (abfd)
 
   /* Allocate and read in the string table.  */
   amt = obj_som_stringtab_size (abfd);
-  stringtab = bfd_malloc (amt);
+  stringtab = bfd_zmalloc (amt);
   if (stringtab == NULL)
     return false;
-  memset (stringtab, 0, obj_som_stringtab_size (abfd));
 
   if (bfd_seek (abfd, obj_som_str_filepos (abfd), SEEK_SET) != 0)
     return false;
@@ -4336,10 +4334,9 @@ som_slurp_symbol_table (abfd)
 
   amt = symbol_count;
   amt *= sizeof (som_symbol_type);
-  symbase = (som_symbol_type *) bfd_malloc (amt);
+  symbase = (som_symbol_type *) bfd_zmalloc (amt);
   if (symbase == NULL)
     goto error_return;
-  memset (symbase, 0, symbol_count * sizeof (som_symbol_type));
 
   /* Read in the external SOM representation.  */
   amt = symbol_count;
@@ -5899,19 +5896,19 @@ som_bfd_ar_write_symbol_stuff (abfd, nsyms, string_size, lst, elength)
 
   amt = lst.hash_size;
   amt *= sizeof (unsigned int);
-  hash_table = (unsigned int *) bfd_malloc (amt);
+  hash_table = (unsigned int *) bfd_zmalloc (amt);
   if (hash_table == NULL && lst.hash_size != 0)
     goto error_return;
 
   amt = lst.module_count;
   amt *= sizeof (struct som_entry);
-  som_dict = (struct som_entry *) bfd_malloc (amt);
+  som_dict = (struct som_entry *) bfd_zmalloc (amt);
   if (som_dict == NULL && lst.module_count != 0)
     goto error_return;
 
   amt = lst.hash_size;
   amt *= sizeof (struct lst_symbol_record *);
-  last_hash_entry = ((struct lst_symbol_record **) bfd_malloc (amt));
+  last_hash_entry = ((struct lst_symbol_record **) bfd_zmalloc (amt));
   if (last_hash_entry == NULL && lst.hash_size != 0)
     goto error_return;
 
@@ -5919,12 +5916,6 @@ som_bfd_ar_write_symbol_stuff (abfd, nsyms, string_size, lst, elength)
      of the lst record.  So save its location.  */
   lst_filepos = bfd_tell (abfd) - sizeof (struct lst_header);
 
-  /* Some initialization.  */
-  memset (hash_table, 0, 4 * lst.hash_size);
-  memset (som_dict, 0, lst.module_count * sizeof (struct som_entry));
-  memset (last_hash_entry, 0,
-         lst.hash_size * sizeof (struct lst_symbol_record *));
-
   /* Symbols have som_index fields, so we have to keep track of the
      index of each SOM in the archive.
 

diff --git a/bfd/sparclinux.c b/bfd/sparclinux.c
index 7f1d270ea3abc04cee62b7b1538f97c47d38bf53..e55a4ffc2b2611a61269e793ae108505a2e05161 100644 (file)
--- a/bfd/sparclinux.c
+++ b/bfd/sparclinux.c
@@ -599,10 +599,9 @@ bfd_sparclinux_size_dynamic_sections (output_bfd, info)
     {
       s->_raw_size = linux_hash_table (info)->fixup_count + 1;
       s->_raw_size *= 8;
-      s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
+      s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
       if (s->contents == NULL)
        return false;
-      memset (s->contents, 0, (size_t) s->_raw_size);
     }
 
   return true;

diff --git a/bfd/sunos.c b/bfd/sunos.c
index 7825a821a0513f985486bb06b6f175dbfaa311ce..5fec6f91d7d1dbf75e7a7534ac2d8f408ba2ee60 100644 (file)
--- a/bfd/sunos.c
+++ b/bfd/sunos.c
@@ -1434,10 +1434,9 @@ bfd_sunos_size_dynamic_sections (output_bfd, info, sdynptr, sneedptr,
       s = bfd_get_section_by_name (dynobj, ".hash");
       BFD_ASSERT (s != NULL);
       hashalloc = (dynsymcount + bucketcount - 1) * HASH_ENTRY_SIZE;
-      s->contents = (bfd_byte *) bfd_alloc (dynobj, hashalloc);
+      s->contents = (bfd_byte *) bfd_zalloc (dynobj, hashalloc);
       if (s->contents == NULL && dynsymcount > 0)
        return false;
-      memset (s->contents, 0, (size_t) hashalloc);
       for (i = 0; i < bucketcount; i++)
        PUT_WORD (output_bfd, (bfd_vma) -1, s->contents + i * HASH_ENTRY_SIZE);
       s->_raw_size = bucketcount * HASH_ENTRY_SIZE;

diff --git a/bfd/tekhex.c b/bfd/tekhex.c
index 8efd401dbda2e4ffcfc05adeb8a04c23896311b2..034ef28b8673bf1407fca849a5bca730395e7aa7 100644 (file)
--- a/bfd/tekhex.c
+++ b/bfd/tekhex.c
@@ -354,17 +354,13 @@ find_chunk (abfd, vma)
     }
   if (!d)
     {
-      char *sname = bfd_alloc (abfd, (bfd_size_type) 12);
-
       /* No chunk for this address, so make one up */
       d = ((struct data_struct *)
-          bfd_alloc (abfd, (bfd_size_type) sizeof (struct data_struct)));
+          bfd_zalloc (abfd, (bfd_size_type) sizeof (struct data_struct)));
 
-      if (!sname || !d)
+      if (!d)
        return NULL;
 
-      memset (d->chunk_init, 0, CHUNK_MASK + 1);
-      memset (d->chunk_data, 0, CHUNK_MASK + 1);
       d->next = abfd->tdata.tekhex_data->data;
       d->vma = vma;
       abfd->tdata.tekhex_data->data = d;

diff --git a/bfd/vms-gsd.c b/bfd/vms-gsd.c
index d9dcd7857896f3773df1c3a5f11f96c1ce28020c..002412232dc2b1c64f37ef73875c478ccb4d2ae3 100644 (file)
--- a/bfd/vms-gsd.c
+++ b/bfd/vms-gsd.c
@@ -426,13 +426,12 @@ _bfd_vms_slurp_gsd (abfd, objtype)
              else
                {
                  section->contents = ((unsigned char *)
-                                      bfd_malloc (section->_raw_size));
+                                      bfd_zmalloc (section->_raw_size));
                  if (section->contents == NULL)
                    {
                      bfd_set_error (bfd_error_no_memory);
                      return -1;
                    }
-                 memset (section->contents, 0, (size_t) section->_raw_size);
                }
              section->_cooked_size = section->_raw_size;
 #if VMS_DEBUG
@@ -618,10 +617,9 @@ _bfd_vms_slurp_gsd (abfd, objtype)
            section->vma = (bfd_vma)base_addr;
            base_addr += section->_raw_size;
            section->contents = ((unsigned char *)
-                                bfd_malloc (section->_raw_size));
+                                bfd_zmalloc (section->_raw_size));
            if (section->contents == NULL)
              return -1;
-           memset (section->contents, 0, (size_t) section->_raw_size);
            section->_cooked_size = section->_raw_size;
 #if VMS_DEBUG
            vms_debug(4, "egsd psc %d (%s, flags %04x=%s) ",

diff --git a/bfd/xcofflink.c b/bfd/xcofflink.c
index 9d66243478c6d6e95bd913f80497f93947f3565b..7215b1bc64a6ac95046081f290bc849ead80971a 100644 (file)
--- a/bfd/xcofflink.c
+++ b/bfd/xcofflink.c
@@ -1086,21 +1086,19 @@ xcoff_link_add_symbols (abfd, info)
   /* We keep a list of the linker hash table entries that correspond
      to each external symbol.  */
   amt = symcount * sizeof (struct xcoff_link_hash_entry *);
-  sym_hash = (struct xcoff_link_hash_entry **) bfd_alloc (abfd, amt);
+  sym_hash = (struct xcoff_link_hash_entry **) bfd_zalloc (abfd, amt);
   if (sym_hash == NULL && symcount != 0)
     goto error_return;
   coff_data (abfd)->sym_hashes = (struct coff_link_hash_entry **) sym_hash;
-  memset (sym_hash, 0, (size_t) amt);
 
   /* Because of the weird stuff we are doing with XCOFF csects, we can
      not easily determine which section a symbol is in, so we store
      the information in the tdata for the input file.  */
   amt = symcount * sizeof (asection *);
-  csect_cache = (asection **) bfd_alloc (abfd, amt);
+  csect_cache = (asection **) bfd_zalloc (abfd, amt);
   if (csect_cache == NULL && symcount != 0)
     goto error_return;
   xcoff_data (abfd)->csects = csect_cache;
-  memset (csect_cache, 0, (size_t) amt);
 
   /* While splitting sections into csects, we need to assign the
      relocs correctly.  The relocs and the csects must both be in
@@ -1109,10 +1107,9 @@ xcoff_link_add_symbols (abfd, info)
      into reloc_info using the section target_index.  */
   amt = abfd->section_count + 1;
   amt *= sizeof (struct reloc_info_struct);
-  reloc_info = (struct reloc_info_struct *) bfd_malloc (amt);
+  reloc_info = (struct reloc_info_struct *) bfd_zmalloc (amt);
   if (reloc_info == NULL)
     goto error_return;
-  memset ((PTR) reloc_info, 0, (size_t) amt);
 
   /* Read in the relocs and line numbers for each section.  */
   linesz = bfd_coff_linesz (abfd);
@@ -1129,11 +1126,9 @@ xcoff_link_add_symbols (abfd, info)
                                        false, (struct internal_reloc *) NULL);
          amt = o->reloc_count;
          amt *= sizeof (asection *);
-         reloc_info[o->target_index].csects = (asection **) bfd_malloc (amt);
+         reloc_info[o->target_index].csects = (asection **) bfd_zmalloc (amt);
          if (reloc_info[o->target_index].csects == NULL)
            goto error_return;
-         memset (reloc_info[o->target_index].csects, 0, (size_t) amt);
-
        }
 
       if ((info->strip == strip_none || info->strip == strip_some)