Changeset 609 for branches/GNU/src/binutils/bfd/coffgen.c

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/bfd/coffgen.c (modified) (108 diffs, 1 prop)

branches/GNU/src/binutils/bfd/coffgen.c

@@ -1 +1 @@
 /* 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.
@@ -47 +47 @@
   PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_size_type *,
            asection **, bfd_size_type *));
-static boolean coff_write_symbol
-  PARAMS ((bfd *, asymbol *, combined_entry_type *, unsigned int *,
+static bfd_boolean coff_write_symbol
+  PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_vma *,
            bfd_size_type *, asection **, bfd_size_type *));
-static boolean coff_write_alien_symbol
-  PARAMS ((bfd *, asymbol *, unsigned int *, bfd_size_type *,
+static bfd_boolean coff_write_alien_symbol
+  PARAMS ((bfd *, asymbol *, bfd_vma *, bfd_size_type *,
            asection **, bfd_size_type *));
-static boolean coff_write_native_symbol
-  PARAMS ((bfd *, coff_symbol_type *, unsigned int *, bfd_size_type *,
+static bfd_boolean coff_write_native_symbol
+  PARAMS ((bfd *, coff_symbol_type *, bfd_vma *, bfd_size_type *,
            asection **, bfd_size_type *));
 static void coff_pointerize_aux
   PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
            unsigned int, combined_entry_type *));
-static boolean make_a_section_from_file
+static bfd_boolean make_a_section_from_file
   PARAMS ((bfd *, struct internal_scnhdr *, unsigned int));
 static const bfd_target *coff_real_object_p
@@ -69 +69 @@
   PARAMS ((bfd *));
 static char *copy_name
-  PARAMS ((bfd *, char *, int));
+  PARAMS ((bfd *, char *, size_t));
 
 #define STRING_SIZE_SIZE (4)
@@ -75 +75 @@
 /* Take a section header read from a coff file (in HOST byte order),
    and make a BFD "section" out of it.  This is used by ECOFF.  */
-static boolean
+static bfd_boolean
 make_a_section_from_file (abfd, hdr, target_index)
      bfd *abfd;
@@ -83 +83 @@
   asection *return_section;
   char *name;
+  bfd_boolean result = TRUE;
+  flagword flags;
 
   name = NULL;
@@ -102 +104 @@
           strings = _bfd_coff_read_string_table (abfd);
           if (strings == NULL)
-            return false;
+            return FALSE;
           /* FIXME: For extra safety, we should make sure that
              strindex does not run us past the end, but right now we
              don't know the length of the string table.  */
           strings += strindex;
-          name = bfd_alloc (abfd, strlen (strings) + 1);
+          name = bfd_alloc (abfd, (bfd_size_type) strlen (strings) + 1);
           if (name == NULL)
-            return false;
+            return FALSE;
           strcpy (name, strings);
         }
@@ -117 +119 @@
     {
       /* Assorted wastage to null-terminate the name, thanks AT&T! */
-      name = bfd_alloc (abfd, sizeof (hdr->s_name) + 1);
+      name = bfd_alloc (abfd, (bfd_size_type) sizeof (hdr->s_name) + 1);
       if (name == NULL)
-        return false;
+        return FALSE;
       strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
       name[sizeof (hdr->s_name)] = 0;
@@ -126 +128 @@
   return_section = bfd_make_section_anyway (abfd, name);
   if (return_section == NULL)
-    return false;
+    return FALSE;
 
   return_section->vma = hdr->s_vaddr;
@@ -143 +145 @@
   return_section->next = (asection *) NULL;
   return_section->target_index = target_index;
-  return_section->flags = bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name,
-                                                           return_section);
+
+  if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section,
+                                         & flags))
+    result = FALSE;
+
+  return_section->flags = flags;
 
   /* At least on i386-coff, the line number count for a shared library
@@ -156 +162 @@
   if (hdr->s_scnptr != 0)
     return_section->flags |= SEC_HAS_CONTENTS;
-  return true;
+
+  return result;
 }
 
@@ -172 +179 @@
   bfd_vma ostart = bfd_get_start_address (abfd);
   PTR tdata;
-  size_t readsize;              /* length of file_info */
+  PTR tdata_save;
+  bfd_size_type readsize;       /* length of file_info */
   unsigned int scnhsz;
   char *external_sections;
@@ -200 +208 @@
   /* Set up the tdata area.  ECOFF uses its own routine, and overrides
      abfd->flags.  */
+  tdata_save = abfd->tdata.any;
   tdata = bfd_coff_mkobject_hook (abfd, (PTR) internal_f, (PTR) internal_a);
   if (tdata == NULL)
-    return 0;
+    goto fail2;
 
   scnhsz = bfd_coff_scnhsz (abfd);
-  readsize = nscns * scnhsz;
+  readsize = (bfd_size_type) nscns * scnhsz;
   external_sections = (char *) bfd_alloc (abfd, readsize);
   if (!external_sections)
     goto fail;
 
-  if (bfd_read ((PTR) external_sections, 1, readsize, abfd) != readsize)
+  if (bfd_bread ((PTR) external_sections, readsize, abfd) != readsize)
     goto fail;
 
   /* Set the arch/mach *before* swapping in sections; section header swapping
      may depend on arch/mach info.  */
-  if (bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f) == false)
+  if (! bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f))
     goto fail;
 
-  /* Now copy data as required; construct all asections etc */
+  /* Now copy data as required; construct all asections etc.  */
   if (nscns != 0)
     {
@@ -233 +242 @@
     }
 
-  /*  make_abs_section (abfd); */
-
   return abfd->xvec;
 
  fail:
   bfd_release (abfd, tdata);
+ fail2:
+  abfd->tdata.any = tdata_save;
   abfd->flags = oflags;
   bfd_get_start_address (abfd) = ostart;
@@ -251 +260 @@
      bfd *abfd;
 {
-  unsigned int filhsz;
-  unsigned int aoutsz;
-  int nscns;
+  bfd_size_type filhsz;
+  bfd_size_type aoutsz;
+  unsigned int nscns;
   PTR filehdr;
   struct internal_filehdr internal_f;
@@ -264 +273 @@
   filehdr = bfd_alloc (abfd, filhsz);
   if (filehdr == NULL)
-    return 0;
-  if (bfd_read (filehdr, 1, filhsz, abfd) != filhsz)
+    return NULL;
+  if (bfd_bread (filehdr, filhsz, abfd) != filhsz)
     {
       if (bfd_get_error () != bfd_error_system_call)
         bfd_set_error (bfd_error_wrong_format);
-      return 0;
+      bfd_release (abfd, filehdr);
+      return NULL;
     }
   bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f);
   bfd_release (abfd, filehdr);
 
-  if (bfd_coff_bad_format_hook (abfd, &internal_f) == false)
+  /* The XCOFF format has two sizes for the f_opthdr.  SMALL_AOUTSZ
+     (less than aoutsz) used in object files and AOUTSZ (equal to
+     aoutsz) in executables.  The bfd_coff_swap_aouthdr_in function
+     expects this header to be aoutsz bytes in length, so we use that
+     value in the call to bfd_alloc below.  But we must be careful to
+     only read in f_opthdr bytes in the call to bfd_bread.  We should
+     also attempt to catch corrupt or non-COFF binaries with a strange
+     value for f_opthdr.  */
+  if (! bfd_coff_bad_format_hook (abfd, &internal_f)
+      || internal_f.f_opthdr > aoutsz)
     {
       bfd_set_error (bfd_error_wrong_format);
-      return 0;
+      return NULL;
     }
   nscns = internal_f.f_nscns;
@@ -287 +306 @@
       opthdr = bfd_alloc (abfd, aoutsz);
       if (opthdr == NULL)
-        return 0;;
-      if (bfd_read (opthdr, 1, internal_f.f_opthdr, abfd)
+        return NULL;
+      if (bfd_bread (opthdr, (bfd_size_type) internal_f.f_opthdr, abfd)
           != internal_f.f_opthdr)
         {
-          return 0;
+          bfd_release (abfd, opthdr);
+          return NULL;
         }
       bfd_coff_swap_aouthdr_in (abfd, opthdr, (PTR) &internal_a);
+      bfd_release (abfd, opthdr);
     }
 
@@ -401 +422 @@
 
 /* Read in and swap the relocs.  This returns a buffer holding the
-   relocs for section SEC in file ABFD.  If CACHE is true and
+   relocs for section SEC in file ABFD.  If CACHE is TRUE and
    INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
    the function is called again.  If EXTERNAL_RELOCS is not NULL, it
    is a buffer large enough to hold the unswapped relocs.  If
    INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
-   the swapped relocs.  If REQUIRE_INTERNAL is true, then the return
+   the swapped relocs.  If REQUIRE_INTERNAL is TRUE, then the return
    value must be INTERNAL_RELOCS.  The function returns NULL on error.  */
 
@@ -414 +435 @@
      bfd *abfd;
      asection *sec;
-     boolean cache;
+     bfd_boolean cache;
      bfd_byte *external_relocs;
-     boolean require_internal;
+     bfd_boolean require_internal;
      struct internal_reloc *internal_relocs;
 {
@@ -425 +446 @@
   bfd_byte *erel_end;
   struct internal_reloc *irel;
+  bfd_size_type amt;
 
   if (coff_section_data (abfd, sec) != NULL
@@ -438 +460 @@
   relsz = bfd_coff_relsz (abfd);
 
+  amt = sec->reloc_count * relsz;
   if (external_relocs == NULL)
     {
-      free_external = (bfd_byte *) bfd_malloc (sec->reloc_count * relsz);
+      free_external = (bfd_byte *) bfd_malloc (amt);
       if (free_external == NULL && sec->reloc_count > 0)
         goto error_return;
@@ -447 +470 @@
 
   if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
-      || (bfd_read (external_relocs, relsz, sec->reloc_count, abfd)
-          != relsz * sec->reloc_count))
+      || bfd_bread (external_relocs, amt, abfd) != amt)
     goto error_return;
 
   if (internal_relocs == NULL)
     {
-      free_internal = ((struct internal_reloc *)
-                       bfd_malloc (sec->reloc_count
-                                   * sizeof (struct internal_reloc)));
+      amt = sec->reloc_count;
+      amt *= sizeof (struct internal_reloc);
+      free_internal = (struct internal_reloc *) bfd_malloc (amt);
       if (free_internal == NULL && sec->reloc_count > 0)
         goto error_return;
@@ -478 +500 @@
       if (coff_section_data (abfd, sec) == NULL)
         {
-          sec->used_by_bfd =
-            (PTR) bfd_zalloc (abfd,
-                              sizeof (struct coff_section_tdata));
+          amt = sizeof (struct coff_section_tdata);
+          sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
           if (sec->used_by_bfd == NULL)
             goto error_return;
@@ -540 +561 @@
               alent *l = q->lineno;
 
-              ++q->symbol.section->output_section->lineno_count;
-              ++total;
-              ++l;
-              while (l->line_number != 0)
+              do
                 {
+                  asection * sec = q->symbol.section->output_section;
+
+                  /* Do not try to update fields in read-only sections.  */
+                  if (! bfd_is_const_section (sec))
+                    sec->lineno_count ++;
+
                   ++total;
-                  ++q->symbol.section->output_section->lineno_count;
                   ++l;
                 }
+              while (l->line_number != 0);
             }
         }
@@ -631 +655 @@
    do that here too.  */
 
-boolean
+bfd_boolean
 coff_renumber_symbols (bfd_ptr, first_undef)
      bfd *bfd_ptr;
@@ -655 +679 @@
     asymbol **newsyms;
     unsigned int i;
-
-    newsyms = (asymbol **) bfd_alloc (bfd_ptr,
-                                      sizeof (asymbol *) * (symbol_count + 1));
+    bfd_size_type amt;
+
+    amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
+    newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt);
     if (!newsyms)
-      return false;
+      return FALSE;
     bfd_ptr->outsymbols = newsyms;
     for (i = 0; i < symbol_count; i++)
@@ -722 +747 @@
   obj_conv_table_size (bfd_ptr) = native_index;
 
-  return true;
+  return TRUE;
 }
 
@@ -751 +776 @@
               /* FIXME: We should use a union here.  */
               s->u.syment.n_value =
-                ((combined_entry_type *) s->u.syment.n_value)->offset;
+                (bfd_vma)((combined_entry_type *)
+                          ((unsigned long) s->u.syment.n_value))->offset;
               s->fix_value = 0;
             }
@@ -869 +895 @@
       else
         {
-          long filepos;
+          file_ptr filepos;
           bfd_byte buf[4];
           int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
@@ -882 +908 @@
           filepos = bfd_tell (abfd);
           if (prefix_len == 4)
-            bfd_put_32 (abfd, name_length + 1, buf);
+            bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf);
           else
-            bfd_put_16 (abfd, name_length + 1, buf);
+            bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf);
 
           if (!bfd_set_section_contents (abfd,
@@ -894 +920 @@
                                             *debug_string_section_p,
                                             (PTR) symbol->name,
-                                            ((file_ptr) *debug_string_size_p
-                                             + prefix_len),
+                                            (file_ptr) (*debug_string_size_p
+                                                        + prefix_len),
                                             (bfd_size_type) name_length + 1))
             abort ();
@@ -916 +942 @@
 /* Write a symbol out to a COFF file.  */
 
-static boolean
+static bfd_boolean
 coff_write_symbol (abfd, symbol, native, written, string_size_p,
                    debug_string_section_p, debug_string_size_p)
@@ -922 +948 @@
      asymbol *symbol;
      combined_entry_type *native;
-     unsigned int *written;
+     bfd_vma *written;
      bfd_size_type *string_size_p;
      asection **debug_string_section_p;
@@ -961 +987 @@
   buf = bfd_alloc (abfd, symesz);
   if (!buf)
-    return false;
+    return FALSE;
   bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
-  if (bfd_write (buf, 1, symesz, abfd) != symesz)
-    return false;
+  if (bfd_bwrite (buf, symesz, abfd) != symesz)
+    return FALSE;
   bfd_release (abfd, buf);
 
@@ -975 +1001 @@
       buf = bfd_alloc (abfd, auxesz);
       if (!buf)
-        return false;
+        return FALSE;
       for (j = 0; j < native->u.syment.n_numaux; j++)
         {
@@ -982 +1008 @@
                                  type,
                                  class,
-                                 j,
+                                 (int) j,
                                  native->u.syment.n_numaux,
                                  buf);
-          if (bfd_write (buf, 1, auxesz, abfd) != auxesz)
-            return false;
+          if (bfd_bwrite (buf, auxesz, abfd) != auxesz)
+            return FALSE;
         }
       bfd_release (abfd, buf);
@@ -995 +1021 @@
 
   *written += numaux + 1;
-  return true;
+  return TRUE;
 }
 
@@ -1002 +1028 @@
    or we may be linking a non COFF file to a COFF file.  */
 
-static boolean
+static bfd_boolean
 coff_write_alien_symbol (abfd, symbol, written, string_size_p,
                          debug_string_section_p, debug_string_size_p)
      bfd *abfd;
      asymbol *symbol;
-     unsigned int *written;
+     bfd_vma *written;
      bfd_size_type *string_size_p;
      asection **debug_string_section_p;
@@ -1035 +1061 @@
          name to keep it from being put in the string table.  */
       symbol->name = "";
-      return true;
+      return TRUE;
     }
   else
@@ -1046 +1072 @@
         native->u.syment.n_value += symbol->section->output_section->vma;
 
-      /* Copy the any flags from the the file header into the symbol.
+      /* Copy the any flags from the file header into the symbol.
          FIXME: Why?  */
       {
@@ -1070 +1096 @@
 /* Write a native symbol to a COFF file.  */
 
-static boolean
+static bfd_boolean
 coff_write_native_symbol (abfd, symbol, written, string_size_p,
                           debug_string_section_p, debug_string_size_p)
      bfd *abfd;
      coff_symbol_type *symbol;
-     unsigned int *written;
+     bfd_vma *written;
      bfd_size_type *string_size_p;
      asection **debug_string_section_p;
@@ -1126 +1152 @@
           count++;
         }
-      symbol->done_lineno = true;
-
-      symbol->symbol.section->output_section->moving_line_filepos +=
-        count * bfd_coff_linesz (abfd);
+      symbol->done_lineno = TRUE;
+
+      if (! bfd_is_const_section (symbol->symbol.section->output_section))
+        symbol->symbol.section->output_section->moving_line_filepos +=
+          count * bfd_coff_linesz (abfd);
     }
 
@@ -1139 +1166 @@
 /* Write out the COFF symbols.  */
 
-boolean
+bfd_boolean
 coff_write_symbols (abfd)
      bfd *abfd;
@@ -1148 +1175 @@
   unsigned int i;
   unsigned int limit = bfd_get_symcount (abfd);
-  unsigned int written = 0;
+  bfd_signed_vma written = 0;
   asymbol **p;
 
@@ -1175 +1202 @@
   /* Seek to the right place */
   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
-    return false;
+    return FALSE;
 
   /* Output all the symbols we have */
@@ -1191 +1218 @@
                                         &debug_string_section,
                                         &debug_string_size))
-            return false;
+            return FALSE;
         }
       else
@@ -1198 +1225 @@
                                          &string_size, &debug_string_section,
                                          &debug_string_size))
-            return false;
+            return FALSE;
         }
     }
@@ -1212 +1239 @@
 
 #if STRING_SIZE_SIZE == 4
-      bfd_h_put_32 (abfd, size, buffer);
+      H_PUT_32 (abfd, size, buffer);
 #else
- #error Change bfd_h_put_32
+ #error Change H_PUT_32
 #endif
-      if (bfd_write ((PTR) buffer, 1, sizeof (buffer), abfd) != sizeof (buffer))
-        return false;
+      if (bfd_bwrite ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd)
+          != sizeof (buffer))
+        return FALSE;
 
       /* Handle long section names.  This code must handle section
@@ -1232 +1260 @@
               if (len > SCNNMLEN)
                 {
-                  if (bfd_write (o->name, 1, len + 1, abfd) != len + 1)
-                    return false;
+                  if (bfd_bwrite (o->name, (bfd_size_type) (len + 1), abfd)
+                      != len + 1)
+                    return FALSE;
                 }
             }
@@ -1272 +1301 @@
             {
               if (bfd_coff_force_symnames_in_strings (abfd))
-                bfd_write (".file", 1, 6, abfd);
+                {
+                  if (bfd_bwrite (".file", (bfd_size_type) 6, abfd) != 6)
+                    return FALSE;
+                }
               maxlen = bfd_coff_filnmlen (abfd);
             }
@@ -1280 +1312 @@
           if (name_length > maxlen)
             {
-              if (bfd_write ((PTR) (q->name), 1, name_length + 1, abfd)
-                  != name_length + 1)
-                return false;
+              if (bfd_bwrite ((PTR) (q->name), (bfd_size_type) name_length + 1,
+                             abfd) != name_length + 1)
+                return FALSE;
             }
         }
@@ -1295 +1327 @@
 
 #if STRING_SIZE_SIZE == 4
-      bfd_h_put_32 (abfd, size, buffer);
+      H_PUT_32 (abfd, size, buffer);
 #else
- #error Change bfd_h_put_32
+ #error Change H_PUT_32
 #endif
-      if (bfd_write ((PTR) buffer, 1, STRING_SIZE_SIZE, abfd)
+      if (bfd_bwrite ((PTR) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd)
           != STRING_SIZE_SIZE)
-        return false;
+        return FALSE;
     }
 
@@ -1315 +1347 @@
                       == bfd_section_size (abfd, debug_string_section))));
 
-  return true;
-}
-
-boolean
+  return TRUE;
+}
+
+bfd_boolean
 coff_write_linenumbers (abfd)
      bfd *abfd;
@@ -1329 +1361 @@
   buff = bfd_alloc (abfd, linesz);
   if (!buff)
-    return false;
+    return FALSE;
   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
     {
@@ -1336 +1368 @@
           asymbol **q = abfd->outsymbols;
           if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
-            return false;
+            return FALSE;
           /* Find all the linenumbers in this section */
           while (*q)
@@ -1354 +1386 @@
                       out.l_addr.l_symndx = l->u.offset;
                       bfd_coff_swap_lineno_out (abfd, &out, buff);
-                      if (bfd_write (buff, 1, linesz, abfd) != linesz)
-                        return false;
+                      if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
+                          != linesz)
+                        return FALSE;
                       l++;
                       while (l->line_number)
@@ -1362 +1395 @@
                           out.l_addr.l_symndx = l->u.offset;
                           bfd_coff_swap_lineno_out (abfd, &out, buff);
-                          if (bfd_write (buff, 1, linesz, abfd) != linesz)
-                            return false;
+                          if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
+                              != linesz)
+                            return FALSE;
                           l++;
                         }
@@ -1373 +1407 @@
     }
   bfd_release (abfd, buff);
-  return true;
+  return TRUE;
 }
 
@@ -1410 +1444 @@
         };
       struct foo *f;
-      f = (struct foo *) bfd_alloc (abfd, sizeof (*f));
+
+      f = (struct foo *) bfd_zalloc (abfd, (bfd_size_type) sizeof (*f));
       if (!f)
         {
@@ -1416 +1451 @@
           return NULL;
         }
-      memset ((char *) f, 0, sizeof (*f));
       coff_symbol_from (abfd, sym)->native = csym = f->e;
     }
@@ -1493 +1527 @@
 {
   char *debug_section;
-  long position;
+  file_ptr position;
+  bfd_size_type sec_size;
 
   asection *sect = bfd_get_section_by_name (abfd, ".debug");
@@ -1503 +1538 @@
     }
 
-  debug_section = (PTR) bfd_alloc (abfd,
-                                   bfd_get_section_size_before_reloc (sect));
+  sec_size = bfd_get_section_size_before_reloc (sect);
+  debug_section = (PTR) bfd_alloc (abfd, sec_size);
   if (debug_section == NULL)
     return NULL;
@@ -1514 +1549 @@
   position = bfd_tell (abfd);
   if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
-      || (bfd_read (debug_section,
-                    bfd_get_section_size_before_reloc (sect), 1, abfd)
-          != bfd_get_section_size_before_reloc (sect))
+      || bfd_bread (debug_section, sec_size, abfd) != sec_size
       || bfd_seek (abfd, position, SEEK_SET) != 0)
     return NULL;
@@ -1529 +1562 @@
      bfd *abfd;
      char *name;
-     int maxlen;
-{
-  int len;
+     size_t maxlen;
+{
+  size_t len;
   char *newname;
 
@@ -1542 +1575 @@
     }
 
-  if ((newname = (PTR) bfd_alloc (abfd, len + 1)) == NULL)
+  if ((newname = (PTR) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
     return (NULL);
   strncpy (newname, name, len);
@@ -1551 +1584 @@
 /* Read in the external symbols.  */
 
-boolean
+bfd_boolean
 _bfd_coff_get_external_symbols (abfd)
      bfd *abfd;
 {
   bfd_size_type symesz;
-  size_t size;
+  bfd_size_type size;
   PTR syms;
 
   if (obj_coff_external_syms (abfd) != NULL)
-    return true;
+    return TRUE;
 
   symesz = bfd_coff_symesz (abfd);
@@ -1568 +1601 @@
   syms = (PTR) bfd_malloc (size);
   if (syms == NULL && size != 0)
-    return false;
+    return FALSE;
 
   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
-      || bfd_read (syms, size, 1, abfd) != size)
+      || bfd_bread (syms, size, abfd) != size)
     {
       if (syms != NULL)
         free (syms);
-      return false;
+      return FALSE;
     }
 
   obj_coff_external_syms (abfd) = syms;
 
-  return true;
+  return TRUE;
 }
 
@@ -1592 +1625 @@
 {
   char extstrsize[STRING_SIZE_SIZE];
-  size_t strsize;
+  bfd_size_type strsize;
   char *strings;
+  file_ptr pos;
 
   if (obj_coff_strings (abfd) != NULL)
@@ -1604 +1638 @@
     }
 
-  if (bfd_seek (abfd,
-                (obj_sym_filepos (abfd)
-                 + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd)),
-                SEEK_SET) != 0)
+  pos = obj_sym_filepos (abfd);
+  pos += obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
+  if (bfd_seek (abfd, pos, SEEK_SET) != 0)
     return NULL;
 
-  if (bfd_read (extstrsize, sizeof extstrsize, 1, abfd) != sizeof extstrsize)
+  if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd)
+      != sizeof extstrsize)
     {
       if (bfd_get_error () != bfd_error_file_truncated)
@@ -1621 +1655 @@
     {
 #if STRING_SIZE_SIZE == 4
-      strsize = bfd_h_get_32 (abfd, (bfd_byte *) extstrsize);
+      strsize = H_GET_32 (abfd, extstrsize);
 #else
- #error Change bfd_h_get_32
+ #error Change H_GET_32
 #endif
     }
@@ -1630 +1664 @@
     {
       (*_bfd_error_handler)
-        (_("%s: bad string table size %lu"), bfd_get_filename (abfd),
+        (_("%s: bad string table size %lu"), bfd_archive_filename (abfd),
          (unsigned long) strsize);
       bfd_set_error (bfd_error_bad_value);
@@ -1640 +1674 @@
     return NULL;
 
-  if (bfd_read (strings + STRING_SIZE_SIZE,
-                strsize - STRING_SIZE_SIZE, 1, abfd)
+  if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
       != strsize - STRING_SIZE_SIZE)
     {
@@ -1655 +1688 @@
 /* Free up the external symbols and strings read from a COFF file.  */
 
-boolean
+bfd_boolean
 _bfd_coff_free_symbols (abfd)
      bfd *abfd;
@@ -1671 +1704 @@
       obj_coff_strings (abfd) = NULL;
     }
-  return true;
+  return TRUE;
 }
 
@@ -1687 +1720 @@
   combined_entry_type *symbol_ptr;
   combined_entry_type *internal_end;
-  bfd_size_type symesz;
+  size_t symesz;
   char *raw_src;
   char *raw_end;
   const char *string_table = NULL;
   char *debug_section = NULL;
-  unsigned long size;
+  bfd_size_type size;
 
   if (obj_raw_syments (abfd) != NULL)
@@ -1735 +1768 @@
                                 symbol_ptr->u.syment.n_type,
                                 symbol_ptr->u.syment.n_sclass,
-                                i, symbol_ptr->u.syment.n_numaux,
+                                (int) i, symbol_ptr->u.syment.n_numaux,
                                 &(internal_ptr->u.auxent));
           coff_pointerize_aux (abfd, internal, symbol_ptr, i,
@@ -1743 +1776 @@
 
   /* Free the raw symbols, but not the strings (if we have them).  */
-  obj_coff_keep_strings (abfd) = true;
+  obj_coff_keep_strings (abfd) = TRUE;
   if (! _bfd_coff_free_symbols (abfd))
     return NULL;
@@ -1790 +1823 @@
                      copy_name (abfd,
                                 (internal_ptr + 1)->u.auxent.x_file.x_fname,
-                                bfd_coff_filnmlen (abfd)));
+                                (size_t) bfd_coff_filnmlen (abfd)));
                 }
             }
@@ -1799 +1832 @@
             {
               /* This is a "short" name.  Make it long.  */
-              unsigned long i = 0;
-              char *newstring = NULL;
+              size_t i;
+              char *newstring;
 
               /* find the length of this string without walking into memory
                  that isn't ours.  */
               for (i = 0; i < 8; ++i)
-                {
-                  if (internal_ptr->u.syment._n._n_name[i] == '\0')
-                    {
-                      break;
-                    }           /* if end of string */
-                }               /* possible lengths of this string.  */
-
-              if ((newstring = (PTR) bfd_alloc (abfd, ++i)) == NULL)
+                if (internal_ptr->u.syment._n._n_name[i] == '\0')
+                  break;
+
+              newstring = (PTR) bfd_zalloc (abfd, (bfd_size_type) (i + 1));
+              if (newstring == NULL)
                 return (NULL);
-              memset (newstring, 0, i);
-              strncpy (newstring, internal_ptr->u.syment._n._n_name, 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;
@@ -1872 +1901 @@
      bfd *abfd;
 {
-  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
+  bfd_size_type amt = sizeof (coff_symbol_type);
+  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;
-  new->done_lineno = false;
+  new->done_lineno = FALSE;
   new->symbol.the_bfd = abfd;
   return &new->symbol;
@@ -1892 +1921 @@
      unsigned long sz ATTRIBUTE_UNUSED;
 {
-  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
+  bfd_size_type amt = sizeof (coff_symbol_type);
+  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, amt);
   if (new == NULL)
     return (NULL);
   /* @@ The 10 is a guess at a plausible maximum number of aux entries
      (but shouldn't be a constant).  */
-  new->native = (combined_entry_type *) bfd_zalloc (abfd, sizeof (combined_entry_type) * 10);
+  amt = sizeof (combined_entry_type) * 10;
+  new->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
   if (!new->native)
     return (NULL);
@@ -1903 +1934 @@
   new->symbol.flags = BSF_DEBUGGING;
   new->lineno = (alent *) NULL;
-  new->done_lineno = false;
+  new->done_lineno = FALSE;
   new->symbol.the_bfd = abfd;
   return &new->symbol;
@@ -1918 +1949 @@
       && coffsymbol (symbol)->native->fix_value)
     {
-      combined_entry_type *psym;
-
-      psym = ((combined_entry_type *)
-              coffsymbol (symbol)->native->u.syment.n_value);
-      ret->value = (bfd_vma) (psym - obj_raw_syments (abfd));
+      ret->value = coffsymbol (symbol)->native->u.syment.n_value -
+        (unsigned long) obj_raw_syments (abfd);
     }
 }
@@ -1928 +1956 @@
 /* Return the COFF syment for a symbol.  */
 
-boolean
+bfd_boolean
 bfd_coff_get_syment (abfd, symbol, psyment)
      bfd *abfd;
@@ -1940 +1968 @@
     {
       bfd_set_error (bfd_error_invalid_operation);
-      return false;
+      return FALSE;
     }
 
@@ -1946 +1974 @@
 
   if (csym->native->fix_value)
-    psyment->n_value = ((combined_entry_type *) psyment->n_value
-                        - obj_raw_syments (abfd));
+    psyment->n_value = psyment->n_value -
+      (unsigned long) obj_raw_syments (abfd);
 
   /* FIXME: We should handle fix_line here.  */
 
-  return true;
+  return TRUE;
 }
 
 /* Return the COFF auxent for a symbol.  */
 
-boolean
+bfd_boolean
 bfd_coff_get_auxent (abfd, symbol, indx, pauxent)
      bfd *abfd;
@@ -1973 +2001 @@
     {
       bfd_set_error (bfd_error_invalid_operation);
-      return false;
+      return FALSE;
     }
 
@@ -1995 +2023 @@
        - obj_raw_syments (abfd));
 
-  return true;
+  return TRUE;
 }
 
@@ -2024 +2052 @@
       if (coffsymbol (symbol)->native)
         {
-          unsigned long val;
+          bfd_vma val;
           unsigned int aux;
           combined_entry_type *combined = coffsymbol (symbol)->native;
@@ -2033 +2061 @@
 
           if (! combined->fix_value)
-            val = (unsigned long) combined->u.syment.n_value;
+            val = (bfd_vma) combined->u.syment.n_value;
           else
-            val = ((unsigned long)
-                   ((combined_entry_type *) combined->u.syment.n_value
-                    - root));
-
+            val = combined->u.syment.n_value - (unsigned long) root;
+
+#ifndef XCOFF64
           fprintf (file,
                    "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s",
@@ -2046 +2073 @@
                    combined->u.syment.n_sclass,
                    combined->u.syment.n_numaux,
+                   (unsigned long) val,
+                   symbol->name);
+#else
+          /* Print out the wide, 64 bit, symbol value */
+          fprintf (file,
+                   "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%016llx %s",
+                   combined->u.syment.n_scnum,
+                   combined->u.syment.n_flags,
+                   combined->u.syment.n_type,
+                   combined->u.syment.n_sclass,
+                   combined->u.syment.n_numaux,
                    val,
                    symbol->name);
+#endif
 
           for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
@@ -2091 +2130 @@
                   if (ISFCN (combined->u.syment.n_type))
                     {
+                      long next, llnos;
+
+                      if (auxp->fix_end)
+                        next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
+                               - root);
+                      else
+                        next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
+                      llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
                       fprintf (file,
-                               _("AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld"),
-                               tagndx,
-                               auxp->u.auxent.x_sym.x_misc.x_fsize,
-                               auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr,
-                               (auxp->fix_end
-                                ? ((long)
-                                   (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
-                                    - root))
-                                : auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l));
+                               "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
+                               tagndx, auxp->u.auxent.x_sym.x_misc.x_fsize,
+                               llnos, next);
                       break;
                     }
@@ -2134 +2175 @@
       else
         {
-          bfd_print_symbol_vandf ((PTR) file, symbol);
+          bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
           fprintf (file, " %-5s %s %s %s",
                    symbol->section->name,
@@ -2149 +2190 @@
    override it.  */
 
-boolean
+bfd_boolean
 _bfd_coff_is_local_label_name (abfd, name)
      bfd *abfd ATTRIBUTE_UNUSED;
@@ -2161 +2202 @@
    nearest to the wanted location.  */
 
-boolean
+bfd_boolean
 coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
                         functionname_ptr, line_ptr)
@@ -2168 +2209 @@
      asymbol **symbols;
      bfd_vma offset;
-     CONST char **filename_ptr;
-     CONST char **functionname_ptr;
+     const char **filename_ptr;
+     const char **functionname_ptr;
      unsigned int *line_ptr;
 {
-  boolean found;
+  bfd_boolean found;
   unsigned int i;
   unsigned int line_base;
@@ -2181 +2222 @@
   alent *l;
   struct coff_section_tdata *sec_data;
+  bfd_size_type amt;
 
   /* Before looking through the symbol table, try to use a .stab
@@ -2188 +2230 @@
                                              functionname_ptr, line_ptr,
                                              &coff_data(abfd)->line_info))
-    return false;
+    return FALSE;
 
   if (found)
-    return true;
+    return TRUE;
 
   /* Also try examining DWARF2 debugging information.  */
@@ -2198 +2240 @@
                                      line_ptr, 0,
                                      &coff_data(abfd)->dwarf2_find_line_info))
-    return true;
+    return TRUE;
 
   *filename_ptr = 0;
@@ -2206 +2248 @@
   /* Don't try and find line numbers in a non coff file */
   if (!bfd_family_coff (abfd))
-    return false;
+    return FALSE;
 
   if (cof == NULL)
-    return false;
+    return FALSE;
 
   /* Find the first C_FILE symbol.  */
   p = cof->raw_syments;
   if (!p)
-    return false;
+    return FALSE;
 
   pend = p + cof->raw_syment_count;
@@ -2265 +2307 @@
           /* Avoid endless loops on erroneous files by ensuring that
              we always move forward in the file.  */
-          if (p - cof->raw_syments >= p->u.syment.n_value)
+          if (p >= cof->raw_syments + p->u.syment.n_value)
             break;
 
@@ -2355 +2397 @@
   if (sec_data == NULL && section->owner == abfd)
     {
-      section->used_by_bfd =
-        ((PTR) bfd_zalloc (abfd,
-                           sizeof (struct coff_section_tdata)));
+      amt = sizeof (struct coff_section_tdata);
+      section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
       sec_data = (struct coff_section_tdata *) section->used_by_bfd;
     }
@@ -2368 +2409 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -2374 +2415 @@
 coff_sizeof_headers (abfd, reloc)
      bfd *abfd;
-     boolean reloc;
+     bfd_boolean reloc;
 {
   size_t size;
 
-  if (reloc == false)
+  if (! reloc)
     {
       size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
@@ -2392 +2433 @@
 
 /* Change the class of a coff symbol held by BFD.  */
-boolean
+bfd_boolean
 bfd_coff_set_symbol_class (abfd, symbol, class)
      bfd *         abfd;
@@ -2404 +2445 @@
     {
       bfd_set_error (bfd_error_invalid_operation);
-      return false;
+      return FALSE;
     }
   else if (csym->native == NULL)
@@ -2414 +2455 @@
 
       combined_entry_type * native;
-
-      native = (combined_entry_type *) bfd_alloc (abfd, sizeof (* native));
+      bfd_size_type amt = sizeof (* native);
+
+      native = (combined_entry_type *) bfd_zalloc (abfd, amt);
       if (native == NULL)
-        return false;
-
-      memset (native, 0, sizeof (* native));
+        return FALSE;
 
       native->u.syment.n_type   = T_NULL;
@@ -2443 +2483 @@
             native->u.syment.n_value += symbol->section->output_section->vma;
 
-          /* Copy the any flags from the the file header into the symbol.
+          /* Copy the any flags from the file header into the symbol.
              FIXME: Why?  */
           native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
@@ -2455 +2495 @@
     }
 
-  return true;
-}
+  return TRUE;
+}