projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Move free_all_objfiles to program_space
[deliverable/binutils-gdb.git] / binutils / srconv.c
diff --git a/binutils/srconv.c b/binutils/srconv.c
index fca3dfdefdaf66b5225e19837e02ebdac87c662c..a421f642e0be73f99a051e1457fab7df607cb219 100644 (file)
--- a/binutils/srconv.c
+++ b/binutils/srconv.c
@@ -1,11 +1,11 @@
 /* srconv.c -- Sysroff conversion program
 /* srconv.c -- Sysroff conversion program
-   Copyright (C) 1994 Free Software Foundation, Inc.
+   Copyright (C) 1994-2019 Free Software Foundation, Inc.
 
    This file is part of GNU Binutils.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GNU Binutils.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -15,7 +15,8 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+   02110-1301, USA.  */
 
 /* Written by Steve Chamberlain (sac@cygnus.com)
 
 
 /* Written by Steve Chamberlain (sac@cygnus.com)
 
@@ -24,25 +25,30 @@
 
    All debugging information is preserved */
 
 
    All debugging information is preserved */
 
-#include <bfd.h>
+#include "sysdep.h"
+#include "bfd.h"
 #include "bucomm.h"
 #include "sysroff.h"
 #include "coffgrok.h"
 #include "bucomm.h"
 #include "sysroff.h"
 #include "coffgrok.h"
-#include <libiberty.h>
-#include <getopt.h>
+#include "libiberty.h"
+#include "filenames.h"
+#include "getopt.h"
 
 #include "coff/internal.h"
 #include "../bfd/libcoff.h"
 
 
 #include "coff/internal.h"
 #include "../bfd/libcoff.h"
 
-#define PROGRAM_VERSION "1.5"
 /*#define FOOP1 1 */
 
 /*#define FOOP1 1 */
 
-static int sh;
-static int h8300;
-static void wr_cs ();
-static void walk_tree_scope ();
-static void wr_globals ();
-static int find_base ();
+static int addrsize;
+static char *toolname;
+static char **rnames;
+
+static void walk_tree_symbol
+  (struct coff_sfile *, struct coff_section *, struct coff_symbol *, int);
+static void walk_tree_scope
+  (struct coff_section *, struct coff_sfile *, struct coff_scope *, int, int);
+static int find_base (struct coff_sfile *, struct coff_section *);
+static void wr_globals (struct coff_ofile *, struct coff_sfile *, int);
 
 static FILE *file;
 static bfd *abfd;
 
 static FILE *file;
 static bfd *abfd;
@@ -50,7 +56,7 @@ static int debug = 0;
 static int quick = 0;
 static int noprescan = 0;
 static struct coff_ofile *tree;
 static int quick = 0;
 static int noprescan = 0;
 static struct coff_ofile *tree;
-/* Obsolete ?? 
+/* Obsolete ??
    static int absolute_p;
  */
 
    static int absolute_p;
  */
 
@@ -63,42 +69,27 @@ static int ids2[20000];
 static int base1 = 0x18;
 static int base2 = 0x2018;
 
 static int base1 = 0x18;
 static int base2 = 0x2018;
 
-char *
-xcalloc (a, b)
-     int a;
-     int b;
-{
-  char *r = xmalloc (a * b);
-  memset (r, 0, a * b);
-  return r;
-}
-
 static int
 static int
-get_member_id (x)
-     int x;
+get_member_id (int x)
 {
   if (ids2[x])
 {
   if (ids2[x])
-    {
-      return ids2[x];
-    }
+    return ids2[x];
+
   ids2[x] = base2++;
   return ids2[x];
 }
 
 static int
   ids2[x] = base2++;
   return ids2[x];
 }
 
 static int
-get_ordinary_id (x)
-     int x;
+get_ordinary_id (int x)
 {
   if (ids1[x])
 {
   if (ids1[x])
-    {
-      return ids1[x];
-    }
+    return ids1[x];
+
   ids1[x] = base1++;
   return ids1[x];
 }
 static char *
   ids1[x] = base1++;
   return ids1[x];
 }
 static char *
-section_translate (n)
-     char *n;
+section_translate (char *n)
 {
   if (strcmp (n, ".text") == 0)
     return "P";
 {
   if (strcmp (n, ".text") == 0)
     return "P";
@@ -109,18 +100,14 @@ section_translate (n)
   return n;
 }
 
   return n;
 }
 
-
-
 #define DATE "940201073000";   /* Just a time on my birthday */
 
 #define DATE "940201073000";   /* Just a time on my birthday */
 
-
-static
-char *
-strip_suffix (name)
-     char *name;
+static char *
+strip_suffix (const char *name)
 {
   int i;
   char *res;
 {
   int i;
   char *res;
+
   for (i = 0; name[i] != 0 && name[i] != '.'; i++)
     ;
   res = (char *) xmalloc (i + 1);
   for (i = 0; name[i] != 0 && name[i] != '.'; i++)
     ;
   res = (char *) xmalloc (i + 1);
@@ -129,64 +116,51 @@ strip_suffix (name)
   return res;
 }
 
   return res;
 }
 
-
 /* IT LEN stuff CS */
 static void
 /* IT LEN stuff CS */
 static void
-checksum (file, ptr, size, code)
-     FILE *file;
-     char *ptr;
-     int size;
-     int code;
+checksum (FILE *ffile, unsigned char *ptr, int size, int ccode)
 {
   int j;
   int last;
   int sum = 0;
   int bytes = size / 8;
 {
   int j;
   int last;
   int sum = 0;
   int bytes = size / 8;
-  last = !(code & 0xff00);
+
+  last = !(ccode & 0xff00);
   if (size & 0x7)
   if (size & 0x7)
-    abort ();
-  ptr[0] = code | (last ? 0x80 : 0);
+    fatal (_("Checksum failure"));
+
+  ptr[0] = ccode | (last ? 0x80 : 0);
   ptr[1] = bytes + 1;
 
   for (j = 0; j < bytes; j++)
   ptr[1] = bytes + 1;
 
   for (j = 0; j < bytes; j++)
-    {
-      sum += ptr[j];
-    }
-  /* Glue on a checksum too */
+    sum += ptr[j];
+
+  /* Glue on a checksum too.  */
   ptr[bytes] = ~sum;
   ptr[bytes] = ~sum;
-  fwrite (ptr, bytes + 1, 1, file);
+  if (fwrite (ptr, bytes + 1, 1, ffile) != 1)
+    /* FIXME: Return error status.  */
+    fatal (_("Failed to write checksum"));
 }
 
 
 }
 
 
-
-
 static void
 static void
-writeINT (n, ptr, idx, size, file)
-     int n;
-     char *ptr;
-     int *idx;
-     int size;
-     FILE *file;
+writeINT (int n, unsigned char *ptr, int *idx, int size, FILE *ffile)
 {
   int byte = *idx / 8;
 
   if (size == -2)
 {
   int byte = *idx / 8;
 
   if (size == -2)
-    {
-      if (sh)  
-       size = 4;
-      else if (h8300)
-       size = 2;
-    }
+    size = addrsize;
   else if (size == -1)
     size = 0;
 
   if (byte > 240)
     {
   else if (size == -1)
     size = 0;
 
   if (byte > 240)
     {
-      /* Lets write out that record and do another one */
-      checksum (file, ptr, *idx, code | 0x1000);
+      /* Lets write out that record and do another one.  */
+      checksum (ffile, ptr, *idx, code | 0x1000);
       *idx = 16;
       byte = *idx / 8;
     }
       *idx = 16;
       byte = *idx / 8;
     }
+
   switch (size)
     {
     case 0:
   switch (size)
     {
     case 0:
@@ -205,75 +179,60 @@ writeINT (n, ptr, idx, size, file)
       ptr[byte + 3] = n >> 0;
       break;
     default:
       ptr[byte + 3] = n >> 0;
       break;
     default:
-      abort ();
+      fatal (_("Unsupported integer write size: %d"), size);
     }
   *idx += size * 8;
 }
 
     }
   *idx += size * 8;
 }
 
-
 static void
 static void
-writeBITS (val, ptr, idx, size)
-     int val;
-     char *ptr;
-     int *idx;
-     int size;
+writeBITS (int val, unsigned char *ptr, int *idx, int size)
 {
   int byte = *idx / 8;
   int bit = *idx % 8;
   int old;
 {
   int byte = *idx / 8;
   int bit = *idx % 8;
   int old;
+
   *idx += size;
 
   old = ptr[byte];
   *idx += size;
 
   old = ptr[byte];
-  /* Turn off all about to change bits */
+  /* Turn off all about to change bits.  */
   old &= ~((~0 >> (8 - bit - size)) & ((1 << size) - 1));
   old &= ~((~0 >> (8 - bit - size)) & ((1 << size) - 1));
-  /* Turn on the bits we want */
+  /* Turn on the bits we want.  */
   old |= (val & ((1 << size) - 1)) << (8 - bit - size);
   ptr[byte] = old;
 }
 
 static void
   old |= (val & ((1 << size) - 1)) << (8 - bit - size);
   ptr[byte] = old;
 }
 
 static void
-writeBARRAY (data, ptr, idx, size, file)
-     barray data;
-     char *ptr;
-     int *idx;
-     int size;
-     FILE *file;
+writeBARRAY (barray data, unsigned char *ptr, int *idx,
+            int size ATTRIBUTE_UNUSED, FILE *ffile)
 {
   int i;
 {
   int i;
-  writeINT (data.len, ptr, idx, 1, file);
+
+  writeINT (data.len, ptr, idx, 1, ffile);
   for (i = 0; i < data.len; i++)
   for (i = 0; i < data.len; i++)
-    {
-      writeINT (data.data[i], ptr, idx, 1, file);
-    }
+    writeINT (data.data[i], ptr, idx, 1, ffile);
 }
 
 }
 
-
 static void
 static void
-writeCHARS (string, ptr, idx, size, file)
-     char *string;
-     char *ptr;
-     int *idx;
-     int size;
-     FILE *file;
+writeCHARS (char *string, unsigned char *ptr, int *idx, int size, FILE *ffile)
 {
   int i = *idx / 8;
 
   if (i > 240)
     {
 {
   int i = *idx / 8;
 
   if (i > 240)
     {
-      /* Lets write out that record and do another one */
-      checksum (file, ptr, *idx, code | 0x1000);
+      /* Lets write out that record and do another one.  */
+      checksum (ffile, ptr, *idx, code | 0x1000);
       *idx = 16;
       i = *idx / 8;
     }
 
   if (size == 0)
     {
       *idx = 16;
       i = *idx / 8;
     }
 
   if (size == 0)
     {
-      /* Variable length string */
+      /* Variable length string.  */
       size = strlen (string);
       ptr[i++] = size;
     }
 
       size = strlen (string);
       ptr[i++] = size;
     }
 
-  /* BUG WAITING TO HAPPEN */
+  /* BUG WAITING TO HAPPEN.  */
   memcpy (ptr + i, string, size);
   i += size;
   *idx = i * 8;
   memcpy (ptr + i, string, size);
   i += size;
   *idx = i * 8;
@@ -282,7 +241,6 @@ writeCHARS (string, ptr, idx, size, file)
 #define SYSROFF_SWAP_OUT
 #include "sysroff.c"
 
 #define SYSROFF_SWAP_OUT
 #include "sysroff.c"
 
-
 static char *rname_sh[] =
 {
   "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"
 static char *rname_sh[] =
 {
   "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"
@@ -294,48 +252,43 @@ static char *rname_h8300[] =
 };
 
 static void
 };
 
 static void
-wr_tr ()
+wr_tr (void)
 {
 {
-  /* The TR block is not normal - it doesn't have any contents. */
+  /* The TR block is not normal - it doesn't have any contents.  */
 
 
-  static char b[] = {
-    0xff,                      /* IT */
-    0x03,                      /* RL */
-    0xfd,                      /* CS */
-  };
-  fwrite (b, 1, sizeof (b), file);
+  static char b[] =
+    {
+      0xff,                    /* IT */
+      0x03,                    /* RL */
+      0xfd,                    /* CS */
+    };
+
+  if (fwrite (b, sizeof (b), 1, file) != 1)
+    /* FIXME: Return error status.  */
+    fatal (_("Failed to write TR block"));
 }
 
 static void
 }
 
 static void
-wr_un (ptr, sfile, first, nsecs)
-     struct coff_ofile *ptr;
-     struct coff_sfile *sfile;
-     int first;
-     int nsecs;
+wr_un (struct coff_ofile *ptr, struct coff_sfile *sfile, int first,
+       int nsecs ATTRIBUTE_UNUSED)
 {
   struct IT_un un;
 {
   struct IT_un un;
-
   struct coff_symbol *s;
 
   un.spare1 = 0;
 
   struct coff_symbol *s;
 
   un.spare1 = 0;
 
-  if (abfd->flags & EXEC_P)
+  if (bfd_get_file_flags (abfd) & EXEC_P)
     un.format = FORMAT_LM;
   else
     un.format = FORMAT_OM;
   un.spare1 = 0;
 
     un.format = FORMAT_LM;
   else
     un.format = FORMAT_OM;
   un.spare1 = 0;
 
-
-#if 0
-  un.nsections = ptr->nsections - 1;   /*  Don't count the abs section */
-#else
-  /*NEW - only count sections with size */
-  un.nsections = nsecs;
-#endif
+  /* Don't count the abs section.  */
+  un.nsections = ptr->nsections - 1;
 
   un.nextdefs = 0;
   un.nextrefs = 0;
 
   un.nextdefs = 0;
   un.nextrefs = 0;
-  /* Count all the undefined and defined variables with global scope */
+  /* Count all the undefined and defined variables with global scope.  */
 
   if (first)
     {
 
   if (first)
     {
@@ -349,10 +302,7 @@ wr_un (ptr, sfile, first, nsecs)
            un.nextrefs++;
        }
     }
            un.nextrefs++;
        }
     }
-  if (sh)
-    un.tool = "C_SH";
-  else if (h8300)
-    un.tool = "C_H8/300H";
+  un.tool = toolname;
   un.tcd = DATE;
   un.linker = "L_GX00";
   un.lcd = DATE;
   un.tcd = DATE;
   un.linker = "L_GX00";
   un.lcd = DATE;
@@ -360,38 +310,56 @@ wr_un (ptr, sfile, first, nsecs)
   sysroff_swap_un_out (file, &un);
 }
 
   sysroff_swap_un_out (file, &un);
 }
 
-
 static void
 static void
-wr_hd (p)
-     struct coff_ofile *p;
+wr_hd (struct coff_ofile *p)
 {
   struct IT_hd hd;
 
   hd.spare1 = 0;
 {
   struct IT_hd hd;
 
   hd.spare1 = 0;
-  if (abfd->flags & EXEC_P)
-    {
-      hd.mt = MTYPE_ABS_LM;
-    }
+  if (bfd_get_file_flags (abfd) & EXEC_P)
+    hd.mt = MTYPE_ABS_LM;
   else
   else
-    {
-      hd.mt = MTYPE_OMS_OR_LMS;
-    }
+    hd.mt = MTYPE_OMS_OR_LMS;
+
   hd.cd = DATE;
 
   hd.nu = p->nsources;         /* Always one unit */
   hd.code = 0;                 /* Always ASCII */
   hd.ver = "0200";             /* Version 2.00 */
   hd.cd = DATE;
 
   hd.nu = p->nsources;         /* Always one unit */
   hd.code = 0;                 /* Always ASCII */
   hd.ver = "0200";             /* Version 2.00 */
-  switch (abfd->arch_info->arch)
+
+  switch (bfd_get_arch (abfd))
     {
     case bfd_arch_h8300:
       hd.au = 8;
       hd.si = 0;
     {
     case bfd_arch_h8300:
       hd.au = 8;
       hd.si = 0;
-      hd.afl = 2;
       hd.spcsz = 32;
       hd.segsz = 0;
       hd.segsh = 0;
       hd.spcsz = 32;
       hd.segsz = 0;
       hd.segsh = 0;
-      hd.cpu = "H8300H";
-      h8300 = 1;
+      switch (bfd_get_mach (abfd))
+       {
+       case bfd_mach_h8300:
+         hd.cpu = "H8300";
+         hd.afl = 2;
+         addrsize = 2;
+         toolname = "C_H8/300";
+         break;
+       case bfd_mach_h8300h:
+         hd.cpu = "H8300H";
+         hd.afl = 4;
+         addrsize = 4;
+         toolname = "C_H8/300H";
+         break;
+       case bfd_mach_h8300s:
+         hd.cpu = "H8300S";
+         hd.afl = 4;
+         addrsize = 4;
+         toolname = "C_H8/300S";
+         break;
+       default:
+         fatal (_("Unrecognized H8300 sub-architecture: %ld"),
+                bfd_get_mach (abfd));
+       }
+      rnames = rname_h8300;
       break;
     case bfd_arch_sh:
       hd.au = 8;
       break;
     case bfd_arch_sh:
       hd.au = 8;
@@ -401,13 +369,15 @@ wr_hd (p)
       hd.segsz = 0;
       hd.segsh = 0;
       hd.cpu = "SH";
       hd.segsz = 0;
       hd.segsh = 0;
       hd.cpu = "SH";
-      sh = 1;
+      addrsize = 4;
+      toolname = "C_SH";
+      rnames = rname_sh;
       break;
     default:
       break;
     default:
-      abort ();
+      fatal (_("Unsupported architecture: %d"), bfd_get_arch (abfd));
     }
 
     }
 
-  if (!abfd->flags & EXEC_P)
+  if (! (bfd_get_file_flags(abfd) & EXEC_P))
     {
       hd.ep = 0;
     }
     {
       hd.ep = 0;
     }
@@ -422,17 +392,14 @@ wr_hd (p)
 
   hd.os = "";
   hd.sys = "";
 
   hd.os = "";
   hd.sys = "";
-  hd.mn = strip_suffix (abfd->filename);
-
+  hd.mn = strip_suffix (bfd_get_filename (abfd));
 
   sysroff_swap_hd_out (file, &hd);
 }
 
 
 static void
 
   sysroff_swap_hd_out (file, &hd);
 }
 
 
 static void
-wr_sh (p, sec)
-     struct coff_ofile *p;
-     struct coff_section *sec;
+wr_sh (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_section *sec)
 {
   struct IT_sh sh;
   sh.unit = 0;
 {
   struct IT_sh sh;
   sh.unit = 0;
@@ -445,27 +412,26 @@ wr_sh (p, sec)
 
 
 static void
 
 
 static void
-wr_ob (p, section)
-     struct coff_ofile *p;
-     struct coff_section *section;
+wr_ob (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_section *section)
 {
 {
-  int i;
+  bfd_size_type i;
   int first = 1;
   unsigned char stuff[200];
 
   i = 0;
   int first = 1;
   unsigned char stuff[200];
 
   i = 0;
-  while (i < section->bfd_section->_raw_size)
+  while (i < bfd_section_size (section->bfd_section))
     {
       struct IT_ob ob;
     {
       struct IT_ob ob;
-      int todo = 200;          /* Copy in 200 byte lumps */
+      int todo = 200;          /* Copy in 200 byte lumps.  */
+
       ob.spare = 0;
       ob.spare = 0;
-      if (i + todo > section->bfd_section->_raw_size)
-       todo = section->bfd_section->_raw_size - i;
+      if (i + todo > bfd_section_size (section->bfd_section))
+       todo = bfd_section_size (section->bfd_section) - i;
 
       if (first)
        {
          ob.saf = 1;
 
       if (first)
        {
          ob.saf = 1;
-         if (abfd->flags & EXEC_P)
+         if (bfd_get_file_flags (abfd) & EXEC_P)
            ob.address = section->address;
          else
            ob.address = 0;
            ob.address = section->address;
          else
            ob.address = 0;
@@ -477,46 +443,47 @@ wr_ob (p, section)
          ob.saf = 0;
        }
 
          ob.saf = 0;
        }
 
-      ob.cpf = 0;              /* Never compress */
+      ob.cpf = 0;              /* Never compress.  */
       ob.data.len = todo;
       bfd_get_section_contents (abfd, section->bfd_section, stuff, i, todo);
       ob.data.data = stuff;
       sysroff_swap_ob_out (file, &ob /*, i + todo < section->size */ );
       i += todo;
     }
       ob.data.len = todo;
       bfd_get_section_contents (abfd, section->bfd_section, stuff, i, todo);
       ob.data.data = stuff;
       sysroff_swap_ob_out (file, &ob /*, i + todo < section->size */ );
       i += todo;
     }
-  /* Now fill the rest with blanks */
-  while (i < section->size)
+
+  /* Now fill the rest with blanks.  */
+  while (i < (bfd_size_type) section->size)
     {
       struct IT_ob ob;
     {
       struct IT_ob ob;
-      int todo = 200;          /* Copy in 200 byte lumps */
+      int todo = 200;          /* Copy in 200 byte lumps.  */
+
       ob.spare = 0;
       ob.spare = 0;
-      if (i + todo > section->size)
+      if (i + todo > (bfd_size_type) section->size)
        todo = section->size - i;
       ob.saf = 0;
 
        todo = section->size - i;
       ob.saf = 0;
 
-      ob.cpf = 0;              /* Never compress */
+      ob.cpf = 0;              /* Never compress.  */
       ob.data.len = todo;
       memset (stuff, 0, todo);
       ob.data.data = stuff;
       sysroff_swap_ob_out (file, &ob);
       i += todo;
     }
       ob.data.len = todo;
       memset (stuff, 0, todo);
       ob.data.data = stuff;
       sysroff_swap_ob_out (file, &ob);
       i += todo;
     }
-  /* Now fill the rest with blanks */
-
+  /* Now fill the rest with blanks.  */
 }
 
 static void
 }
 
 static void
-wr_rl (ptr, sec)
-     struct coff_ofile *ptr;
-     struct coff_section *sec;
+wr_rl (struct coff_ofile *ptr ATTRIBUTE_UNUSED, struct coff_section *sec)
 {
   int nr = sec->nrelocs;
   int i;
 {
   int nr = sec->nrelocs;
   int i;
+
   for (i = 0; i < nr; i++)
     {
       struct coff_reloc *r = sec->relocs + i;
       struct coff_symbol *ref;
       struct IT_rl rl;
   for (i = 0; i < nr; i++)
     {
       struct coff_reloc *r = sec->relocs + i;
       struct coff_symbol *ref;
       struct IT_rl rl;
+
       rl.apol = 0;
       rl.boundary = 0;
       rl.segment = 1;
       rl.apol = 0;
       rl.boundary = 0;
       rl.segment = 1;
@@ -524,18 +491,19 @@ wr_rl (ptr, sec)
       rl.check = 0;
       rl.addr = r->offset;
       rl.bitloc = 0;
       rl.check = 0;
       rl.addr = r->offset;
       rl.bitloc = 0;
-      rl.flen = 32;            /* SH Specific */
-      /* What sort of reloc ? Look in the section to find out */
+      rl.flen = 32;            /* SH Specific.  */
+
+      /* What sort of reloc ? Look in the section to find out.  */
       ref = r->symbol;
       if (ref->visible->type == coff_vis_ext_ref)
        {
       ref = r->symbol;
       if (ref->visible->type == coff_vis_ext_ref)
        {
-         rl.bcount = 4;        /* Always 4 for us */
+         rl.bcount = 4;        /* Always 4 for us.  */
          rl.op = OP_EXT_REF;
          rl.symn = ref->er_number;
        }
       else if (ref->visible->type == coff_vis_common)
        {
          rl.op = OP_EXT_REF;
          rl.symn = ref->er_number;
        }
       else if (ref->visible->type == coff_vis_common)
        {
-         rl.bcount = 11;       /* Always 11 for us */
+         rl.bcount = 11;       /* Always 11 for us.  */
          rl.op = OP_SEC_REF;
          rl.secn = ref->where->section->number;
          rl.copcode_is_3 = 3;
          rl.op = OP_SEC_REF;
          rl.secn = ref->where->section->number;
          rl.copcode_is_3 = 3;
@@ -543,10 +511,9 @@ wr_rl (ptr, sec)
          rl.addend = ref->where->offset - ref->where->section->address;
          rl.aopcode_is_0x20 = 0x20;
        }
          rl.addend = ref->where->offset - ref->where->section->address;
          rl.aopcode_is_0x20 = 0x20;
        }
-
       else
        {
       else
        {
-         rl.bcount = 11;       /* Always 11 for us */
+         rl.bcount = 11;       /* Always 11 for us.  */
          rl.op = OP_SEC_REF;
          rl.secn = ref->where->section->number;
          rl.copcode_is_3 = 3;
          rl.op = OP_SEC_REF;
          rl.secn = ref->where->section->number;
          rl.copcode_is_3 = 3;
@@ -554,20 +521,20 @@ wr_rl (ptr, sec)
          rl.addend = -ref->where->section->address;
          rl.aopcode_is_0x20 = 0x20;
        }
          rl.addend = -ref->where->section->address;
          rl.aopcode_is_0x20 = 0x20;
        }
+
       rl.end = 0xff;
       rl.end = 0xff;
-      if (rl.op == OP_SEC_REF
+
+      if (   rl.op == OP_SEC_REF
          || rl.op == OP_EXT_REF)
          || rl.op == OP_EXT_REF)
-       {
-         sysroff_swap_rl_out (file, &rl);
-       }
+       sysroff_swap_rl_out (file, &rl);
     }
 }
 
 static void
     }
 }
 
 static void
-wr_object_body (p)
-     struct coff_ofile *p;
+wr_object_body (struct coff_ofile *p)
 {
   int i;
 {
   int i;
+
   for (i = 1; i < p->nsections; i++)
     {
       wr_sh (p, p->sections + i);
   for (i = 1; i < p->nsections; i++)
     {
       wr_sh (p, p->sections + i);
@@ -577,29 +544,28 @@ wr_object_body (p)
 }
 
 static void
 }
 
 static void
-wr_dps_start (sfile, section, scope, type, nest)
-     struct coff_sfile *sfile;
-     struct coff_section *section;
-     struct coff_scope *scope;
-     int type;
-     int nest;
+wr_dps_start (struct coff_sfile *sfile,
+             struct coff_section *section ATTRIBUTE_UNUSED,
+             struct coff_scope *scope, int type, int nest)
 {
   struct IT_dps dps;
 {
   struct IT_dps dps;
+
   dps.end = 0;
   dps.opt = 0;
   dps.type = type;
   dps.end = 0;
   dps.opt = 0;
   dps.type = type;
+
   if (scope->sec)
     {
       dps.san = scope->sec->number;
       dps.address = scope->offset - find_base (sfile, scope->sec);
       dps.block_size = scope->size;
   if (scope->sec)
     {
       dps.san = scope->sec->number;
       dps.address = scope->offset - find_base (sfile, scope->sec);
       dps.block_size = scope->size;
+
       if (debug)
        {
          printf ("DPS %s %d %x\n",
                  sfile->name,
                  nest,
                  dps.address);
       if (debug)
        {
          printf ("DPS %s %d %x\n",
                  sfile->name,
                  nest,
                  dps.address);
-
        }
     }
   else
        }
     }
   else
@@ -615,31 +581,25 @@ wr_dps_start (sfile, section, scope, type, nest)
 }
 
 static void
 }
 
 static void
-wr_dps_end (section, scope, type)
-     struct coff_section *section;
-     struct coff_scope *scope;
-     int type;
+wr_dps_end (struct coff_section *section ATTRIBUTE_UNUSED,
+           struct coff_scope *scope ATTRIBUTE_UNUSED, int type)
 {
   struct IT_dps dps;
 {
   struct IT_dps dps;
+
   dps.end = 1;
   dps.type = type;
   sysroff_swap_dps_out (file, &dps);
 }
 
 static int *
   dps.end = 1;
   dps.type = type;
   sysroff_swap_dps_out (file, &dps);
 }
 
 static int *
-nints (x)
-     int x;
+nints (int x)
 {
   return (int *) (xcalloc (sizeof (int), x));
 }
 
 {
   return (int *) (xcalloc (sizeof (int), x));
 }
 
-static void walk_tree_symbol ();
 static void
 static void
-walk_tree_type_1 (sfile, symbol, type, nest)
-     struct coff_sfile *sfile;
-     struct coff_symbol *symbol;
-     struct coff_type *type;
-     int nest;
+walk_tree_type_1 (struct coff_sfile *sfile, struct coff_symbol *symbol,
+                 struct coff_type *type, int nest)
 {
   switch (type->type)
     {
 {
   switch (type->type)
     {
@@ -656,11 +616,13 @@ walk_tree_type_1 (sfile, symbol, type, nest)
            dbt.sign = BTYPE_UNSPEC;
            dbt.fptype = FPTYPE_NOTSPEC;
            break;
            dbt.sign = BTYPE_UNSPEC;
            dbt.fptype = FPTYPE_NOTSPEC;
            break;
+
          case T_CHAR:
            dbt.btype = BTYPE_CHAR;
            dbt.sign = BTYPE_UNSPEC;
            dbt.fptype = FPTYPE_NOTSPEC;
            break;
          case T_CHAR:
            dbt.btype = BTYPE_CHAR;
            dbt.sign = BTYPE_UNSPEC;
            dbt.fptype = FPTYPE_NOTSPEC;
            break;
+
          case T_SHORT:
          case T_INT:
          case T_LONG:
          case T_SHORT:
          case T_INT:
          case T_LONG:
@@ -668,23 +630,28 @@ walk_tree_type_1 (sfile, symbol, type, nest)
            dbt.sign = SIGN_SIGNED;
            dbt.fptype = FPTYPE_NOTSPEC;
            break;
            dbt.sign = SIGN_SIGNED;
            dbt.fptype = FPTYPE_NOTSPEC;
            break;
+
          case T_FLOAT:
            dbt.btype = BTYPE_FLOAT;
            dbt.fptype = FPTYPE_SINGLE;
            break;
          case T_FLOAT:
            dbt.btype = BTYPE_FLOAT;
            dbt.fptype = FPTYPE_SINGLE;
            break;
+
          case T_DOUBLE:
            dbt.btype = BTYPE_FLOAT;
            dbt.fptype = FPTYPE_DOUBLE;
            break;
          case T_DOUBLE:
            dbt.btype = BTYPE_FLOAT;
            dbt.fptype = FPTYPE_DOUBLE;
            break;
+
          case T_LNGDBL:
            dbt.btype = BTYPE_FLOAT;
            dbt.fptype = FPTYPE_EXTENDED;
            break;
          case T_LNGDBL:
            dbt.btype = BTYPE_FLOAT;
            dbt.fptype = FPTYPE_EXTENDED;
            break;
+
          case T_UCHAR:
            dbt.btype = BTYPE_CHAR;
            dbt.sign = SIGN_UNSIGNED;
            dbt.fptype = FPTYPE_NOTSPEC;
            break;
          case T_UCHAR:
            dbt.btype = BTYPE_CHAR;
            dbt.sign = SIGN_UNSIGNED;
            dbt.fptype = FPTYPE_NOTSPEC;
            break;
+
          case T_USHORT:
          case T_UINT:
          case T_ULONG:
          case T_USHORT:
          case T_UINT:
          case T_ULONG:
@@ -693,14 +660,18 @@ walk_tree_type_1 (sfile, symbol, type, nest)
            dbt.fptype = FPTYPE_NOTSPEC;
            break;
          }
            dbt.fptype = FPTYPE_NOTSPEC;
            break;
          }
+
        dbt.bitsize = type->size;
        dbt.neg = 0x1001;
        sysroff_swap_dbt_out (file, &dbt);
        break;
       }
        dbt.bitsize = type->size;
        dbt.neg = 0x1001;
        sysroff_swap_dbt_out (file, &dbt);
        break;
       }
+
     case coff_pointer_type:
       {
        struct IT_dpt dpt;
     case coff_pointer_type:
       {
        struct IT_dpt dpt;
+
+       dpt.dunno = 0;
        walk_tree_type_1 (sfile, symbol, type->u.pointer.points_to, nest + 1);
        dpt.neg = 0x1001;
        sysroff_swap_dpt_out (file, &dpt);
        walk_tree_type_1 (sfile, symbol, type->u.pointer.points_to, nest + 1);
        dpt.neg = 0x1001;
        sysroff_swap_dpt_out (file, &dpt);
@@ -711,6 +682,7 @@ walk_tree_type_1 (sfile, symbol, type, nest)
       {
        struct IT_dfp dfp;
        struct coff_symbol *param;
       {
        struct IT_dfp dfp;
        struct coff_symbol *param;
+
        dfp.end = 0;
        dfp.spare = 0;
        dfp.nparams = type->u.function.parameters->nvars;
        dfp.end = 0;
        dfp.spare = 0;
        dfp.nparams = type->u.function.parameters->nvars;
@@ -723,9 +695,8 @@ walk_tree_type_1 (sfile, symbol, type, nest)
        for (param = type->u.function.parameters->vars_head;
             param;
             param = param->next)
        for (param = type->u.function.parameters->vars_head;
             param;
             param = param->next)
-         {
-           walk_tree_symbol (sfile, 0, param, nest);
-         }
+         walk_tree_symbol (sfile, 0, param, nest);
+
        dfp.end = 1;
        sysroff_swap_dfp_out (file, &dfp);
        break;
        dfp.end = 1;
        sysroff_swap_dfp_out (file, &dfp);
        break;
@@ -736,6 +707,7 @@ walk_tree_type_1 (sfile, symbol, type, nest)
        struct IT_dbt dbt;
        struct IT_dds dds;
        struct coff_symbol *member;
        struct IT_dbt dbt;
        struct IT_dds dds;
        struct coff_symbol *member;
+
        dds.spare = 0;
        dbt.btype = BTYPE_STRUCT;
        dbt.bitsize = type->size;
        dds.spare = 0;
        dbt.btype = BTYPE_STRUCT;
        dbt.bitsize = type->size;
@@ -747,43 +719,43 @@ walk_tree_type_1 (sfile, symbol, type, nest)
        dds.end = 0;
        dds.neg = 0x1001;
        sysroff_swap_dds_out (file, &dds);
        dds.end = 0;
        dds.neg = 0x1001;
        sysroff_swap_dds_out (file, &dds);
+
        for (member = type->u.astructdef.elements->vars_head;
             member;
             member = member->next)
        for (member = type->u.astructdef.elements->vars_head;
             member;
             member = member->next)
-         {
-           walk_tree_symbol (sfile, 0, member, nest + 1);
-         }
+         walk_tree_symbol (sfile, 0, member, nest + 1);
 
        dds.end = 1;
        sysroff_swap_dds_out (file, &dds);
 
       }
       break;
 
        dds.end = 1;
        sysroff_swap_dds_out (file, &dds);
 
       }
       break;
+
     case coff_structref_type:
       {
        struct IT_dbt dbt;
     case coff_structref_type:
       {
        struct IT_dbt dbt;
+
        dbt.btype = BTYPE_TAG;
        dbt.bitsize = type->size;
        dbt.sign = SIGN_UNSPEC;
        dbt.fptype = FPTYPE_NOTSPEC;
        dbt.btype = BTYPE_TAG;
        dbt.bitsize = type->size;
        dbt.sign = SIGN_UNSPEC;
        dbt.fptype = FPTYPE_NOTSPEC;
+
        if (type->u.astructref.ref)
        if (type->u.astructref.ref)
-         {
-           dbt.sid = get_member_id (type->u.astructref.ref->number);
-         }
+         dbt.sid = get_member_id (type->u.astructref.ref->number);
        else
        else
-         {
-           dbt.sid = 0;
-         }
+         dbt.sid = 0;
 
        dbt.neg = 0x1001;
        sysroff_swap_dbt_out (file, &dbt);
       }
       break;
 
        dbt.neg = 0x1001;
        sysroff_swap_dbt_out (file, &dbt);
       }
       break;
+
     case coff_array_type:
       {
        struct IT_dar dar;
        int j;
     case coff_array_type:
       {
        struct IT_dar dar;
        int j;
-       int dims = 1;           /* Only output one dimension at a time */
+       int dims = 1;           /* Only output one dimension at a time.  */
+
        dar.dims = dims;
        dar.variable = nints (dims);
        dar.subtype = nints (dims);
        dar.dims = dims;
        dar.variable = nints (dims);
        dar.subtype = nints (dims);
@@ -796,6 +768,7 @@ walk_tree_type_1 (sfile, symbol, type, nest)
        dar.minspare = nints (dims);
        dar.neg = 0x1001;
        dar.length = type->size / type->u.array.dim;
        dar.minspare = nints (dims);
        dar.neg = 0x1001;
        dar.length = type->size / type->u.array.dim;
+
        for (j = 0; j < dims; j++)
          {
            dar.variable[j] = VARIABLE_FIXED;
        for (j = 0; j < dims; j++)
          {
            dar.variable[j] = VARIABLE_FIXED;
@@ -810,11 +783,13 @@ walk_tree_type_1 (sfile, symbol, type, nest)
        sysroff_swap_dar_out (file, &dar);
       }
       break;
        sysroff_swap_dar_out (file, &dar);
       }
       break;
+
     case coff_enumdef_type:
       {
        struct IT_dbt dbt;
        struct IT_den den;
        struct coff_symbol *member;
     case coff_enumdef_type:
       {
        struct IT_dbt dbt;
        struct IT_den den;
        struct coff_symbol *member;
+
        dbt.btype = BTYPE_ENUM;
        dbt.bitsize = type->size;
        dbt.sign = SIGN_UNSPEC;
        dbt.btype = BTYPE_ENUM;
        dbt.bitsize = type->size;
        dbt.sign = SIGN_UNSPEC;
@@ -827,22 +802,21 @@ walk_tree_type_1 (sfile, symbol, type, nest)
        den.neg = 0x1001;
        den.spare = 0;
        sysroff_swap_den_out (file, &den);
        den.neg = 0x1001;
        den.spare = 0;
        sysroff_swap_den_out (file, &den);
+
        for (member = type->u.aenumdef.elements->vars_head;
             member;
             member = member->next)
        for (member = type->u.aenumdef.elements->vars_head;
             member;
             member = member->next)
-         {
-           walk_tree_symbol (sfile, 0, member, nest + 1);
-         }
+         walk_tree_symbol (sfile, 0, member, nest + 1);
 
        den.end = 1;
        sysroff_swap_den_out (file, &den);
       }
       break;
 
 
        den.end = 1;
        sysroff_swap_den_out (file, &den);
       }
       break;
 
-      break;
     case coff_enumref_type:
       {
        struct IT_dbt dbt;
     case coff_enumref_type:
       {
        struct IT_dbt dbt;
+
        dbt.btype = BTYPE_TAG;
        dbt.bitsize = type->size;
        dbt.sign = SIGN_UNSPEC;
        dbt.btype = BTYPE_TAG;
        dbt.bitsize = type->size;
        dbt.sign = SIGN_UNSPEC;
@@ -852,12 +826,13 @@ walk_tree_type_1 (sfile, symbol, type, nest)
        sysroff_swap_dbt_out (file, &dbt);
       }
       break;
        sysroff_swap_dbt_out (file, &dbt);
       }
       break;
+
     default:
     default:
-      abort ();
+      fatal (_("Unrecognised type: %d"), type->type);
     }
 }
 
     }
 }
 
-/* Obsolete ? 
+/* Obsolete ?
    static void
    dty_start ()
    {
    static void
    dty_start ()
    {
@@ -896,21 +871,17 @@ walk_tree_type_1 (sfile, symbol, type, nest)
  */
 
 static void
  */
 
 static void
-walk_tree_type (sfile, symbol, type, nest)
-
-     struct
-     coff_sfile *sfile;
-     struct coff_symbol *symbol;
-     struct coff_type *type;
-     int nest;
+walk_tree_type (struct coff_sfile *sfile, struct coff_symbol *symbol,
+               struct coff_type *type, int nest)
 {
 {
-  if (symbol->type->type == coff_function_type)
-    {
+  struct IT_dty dty;
 
 
-      struct IT_dty dty;
-      dty.end = 0;
-      dty.neg = 0x1001;
+  dty.spare = 0;
+  dty.end = 0;
+  dty.neg = 0x1001;
 
 
+  if (symbol->type->type == coff_function_type)
+    {
       sysroff_swap_dty_out (file, &dty);
       walk_tree_type_1 (sfile, symbol, type, nest);
       dty.end = 1;
       sysroff_swap_dty_out (file, &dty);
       walk_tree_type_1 (sfile, symbol, type, nest);
       dty.end = 1;
@@ -933,33 +904,22 @@ walk_tree_type (sfile, symbol, type, nest)
                  BLOCK_TYPE_BLOCK);
       wr_dps_end (symbol->where->section,
                  symbol->type->u.function.code, BLOCK_TYPE_FUNCTION);
                  BLOCK_TYPE_BLOCK);
       wr_dps_end (symbol->where->section,
                  symbol->type->u.function.code, BLOCK_TYPE_FUNCTION);
-
     }
   else
     {
     }
   else
     {
-      struct IT_dty dty;
-      dty.end = 0;
-      dty.neg = 0x1001;
       sysroff_swap_dty_out (file, &dty);
       walk_tree_type_1 (sfile, symbol, type, nest);
       dty.end = 1;
       sysroff_swap_dty_out (file, &dty);
     }
       sysroff_swap_dty_out (file, &dty);
       walk_tree_type_1 (sfile, symbol, type, nest);
       dty.end = 1;
       sysroff_swap_dty_out (file, &dty);
     }
-
 }
 
 }
 
-
-
 static void
 static void
-walk_tree_symbol (sfile, section, symbol, nest)
-     struct coff_sfile *sfile;
-     struct coff_section *section;
-     struct coff_symbol *symbol;
-     int nest;
+walk_tree_symbol (struct coff_sfile *sfile, struct coff_section *section ATTRIBUTE_UNUSED, struct coff_symbol *symbol, int nest)
 {
   struct IT_dsy dsy;
 
 {
   struct IT_dsy dsy;
 
-  dsy.spare2 = 0;
+  memset (&dsy, 0, sizeof(dsy));
   dsy.nesting = nest;
 
   switch (symbol->type->type)
   dsy.nesting = nest;
 
   switch (symbol->type->type)
@@ -968,6 +928,7 @@ walk_tree_symbol (sfile, section, symbol, nest)
       dsy.type = STYPE_FUNC;
       dsy.assign = 1;
       break;
       dsy.type = STYPE_FUNC;
       dsy.assign = 1;
       break;
+
     case coff_structref_type:
     case coff_pointer_type:
     case coff_array_type:
     case coff_structref_type:
     case coff_pointer_type:
     case coff_array_type:
@@ -976,20 +937,24 @@ walk_tree_symbol (sfile, section, symbol, nest)
       dsy.type = STYPE_VAR;
       dsy.assign = 1;
       break;
       dsy.type = STYPE_VAR;
       dsy.assign = 1;
       break;
+
     case coff_enumdef_type:
       dsy.type = STYPE_TAG;
       dsy.assign = 0;
       dsy.magic = 2;
       break;
     case coff_enumdef_type:
       dsy.type = STYPE_TAG;
       dsy.assign = 0;
       dsy.magic = 2;
       break;
+
     case coff_structdef_type:
       dsy.type = STYPE_TAG;
       dsy.assign = 0;
       dsy.magic = symbol->type->u.astructdef.isstruct ? 0 : 1;
       break;
     case coff_structdef_type:
       dsy.type = STYPE_TAG;
       dsy.assign = 0;
       dsy.magic = symbol->type->u.astructdef.isstruct ? 0 : 1;
       break;
+
     case coff_secdef_type:
       return;
     case coff_secdef_type:
       return;
+
     default:
     default:
-      abort ();
+      fatal (_("Unrecognised coff symbol type: %d"), symbol->type->type);
     }
 
   if (symbol->where->where == coff_where_member_of_struct)
     }
 
   if (symbol->where->where == coff_where_member_of_struct)
@@ -997,6 +962,7 @@ walk_tree_symbol (sfile, section, symbol, nest)
       dsy.assign = 0;
       dsy.type = STYPE_MEMBER;
     }
       dsy.assign = 0;
       dsy.type = STYPE_MEMBER;
     }
+
   if (symbol->where->where == coff_where_member_of_enum)
     {
       dsy.type = STYPE_ENUM;
   if (symbol->where->where == coff_where_member_of_enum)
     {
       dsy.type = STYPE_ENUM;
@@ -1016,7 +982,6 @@ walk_tree_symbol (sfile, section, symbol, nest)
       dsy.snumber = get_ordinary_id (symbol->number);
     }
 
       dsy.snumber = get_ordinary_id (symbol->number);
     }
 
-
   dsy.sname = symbol->name[0] == '_' ? symbol->name + 1 : symbol->name;
 
   switch (symbol->visible->type)
   dsy.sname = symbol->name[0] == '_' ? symbol->name + 1 : symbol->name;
 
   switch (symbol->visible->type)
@@ -1025,30 +990,37 @@ walk_tree_symbol (sfile, section, symbol, nest)
     case coff_vis_ext_def:
       dsy.ainfo = AINFO_STATIC_EXT_DEF;
       break;
     case coff_vis_ext_def:
       dsy.ainfo = AINFO_STATIC_EXT_DEF;
       break;
+
     case coff_vis_ext_ref:
       dsy.ainfo = AINFO_STATIC_EXT_REF;
       break;
     case coff_vis_ext_ref:
       dsy.ainfo = AINFO_STATIC_EXT_REF;
       break;
+
     case coff_vis_int_def:
       dsy.ainfo = AINFO_STATIC_INT;
       break;
     case coff_vis_int_def:
       dsy.ainfo = AINFO_STATIC_INT;
       break;
+
     case coff_vis_auto:
     case coff_vis_autoparam:
       dsy.ainfo = AINFO_AUTO;
       break;
     case coff_vis_auto:
     case coff_vis_autoparam:
       dsy.ainfo = AINFO_AUTO;
       break;
+
     case coff_vis_register:
     case coff_vis_regparam:
       dsy.ainfo = AINFO_REG;
       break;
       break;
     case coff_vis_register:
     case coff_vis_regparam:
       dsy.ainfo = AINFO_REG;
       break;
       break;
+
     case coff_vis_tag:
     case coff_vis_member_of_struct:
     case coff_vis_member_of_enum:
       break;
     case coff_vis_tag:
     case coff_vis_member_of_struct:
     case coff_vis_member_of_enum:
       break;
+
     default:
     default:
-      abort ();
+      fatal (_("Unrecognised coff symbol visibility: %d"), symbol->visible->type);
     }
 
   dsy.dlength = symbol->type->size;
     }
 
   dsy.dlength = symbol->type->size;
+
   switch (symbol->where->where)
     {
     case coff_where_memory:
   switch (symbol->where->where)
     {
     case coff_where_memory:
@@ -1058,18 +1030,19 @@ walk_tree_symbol (sfile, section, symbol, nest)
       dsy.section = 0;
 #endif
       break;
       dsy.section = 0;
 #endif
       break;
+
     case coff_where_member_of_struct:
     case coff_where_member_of_enum:
     case coff_where_stack:
     case coff_where_register:
     case coff_where_unknown:
     case coff_where_strtag:
     case coff_where_member_of_struct:
     case coff_where_member_of_enum:
     case coff_where_stack:
     case coff_where_register:
     case coff_where_unknown:
     case coff_where_strtag:
-
     case coff_where_entag:
     case coff_where_typedef:
       break;
     case coff_where_entag:
     case coff_where_typedef:
       break;
+
     default:
     default:
-      abort ();
+      fatal (_("Unrecognised coff symbol location: %d"), symbol->where->where);
     }
 
   switch (symbol->where->where)
     }
 
   switch (symbol->where->where)
@@ -1077,12 +1050,12 @@ walk_tree_symbol (sfile, section, symbol, nest)
     case coff_where_memory:
       dsy.address = symbol->where->offset - find_base (sfile, symbol->where->section);
       break;
     case coff_where_memory:
       dsy.address = symbol->where->offset - find_base (sfile, symbol->where->section);
       break;
+
     case coff_where_stack:
       dsy.address = symbol->where->offset;
       break;
     case coff_where_stack:
       dsy.address = symbol->where->offset;
       break;
-    case coff_where_member_of_struct:
-
 
 
+    case coff_where_member_of_struct:
       if (symbol->where->bitsize)
        {
          int bits = (symbol->where->offset * 8 + symbol->where->bitoffset);
       if (symbol->where->bitsize)
        {
          int bits = (symbol->where->offset * 8 + symbol->where->bitoffset);
@@ -1099,37 +1072,33 @@ walk_tree_symbol (sfile, section, symbol, nest)
          dsy.field_off = symbol->where->offset;
        }
       break;
          dsy.field_off = symbol->where->offset;
        }
       break;
+
     case coff_where_member_of_enum:
       /*      dsy.bitunit = 0;
          dsy.field_len  = symbol->type->size;
          dsy.field_off = symbol->where->offset; */
       break;
     case coff_where_member_of_enum:
       /*      dsy.bitunit = 0;
          dsy.field_len  = symbol->type->size;
          dsy.field_off = symbol->where->offset; */
       break;
+
     case coff_where_register:
     case coff_where_unknown:
     case coff_where_strtag:
     case coff_where_register:
     case coff_where_unknown:
     case coff_where_strtag:
-
     case coff_where_entag:
     case coff_where_typedef:
       break;
     case coff_where_entag:
     case coff_where_typedef:
       break;
+
     default:
     default:
-      abort ();
+      fatal (_("Unrecognised coff symbol location: %d"), symbol->where->where);
     }
 
   if (symbol->where->where == coff_where_register)
     }
 
   if (symbol->where->where == coff_where_register)
-    {
-      if (sh)
-       dsy.reg = rname_sh[symbol->where->offset];
-      else if (h8300)
-       dsy.reg = rname_h8300[symbol->where->offset];
-    }
+    dsy.reg = rnames[symbol->where->offset];
 
   switch (symbol->visible->type)
     {
     case coff_vis_common:
 
   switch (symbol->visible->type)
     {
     case coff_vis_common:
-      /* We do this 'cause common C symbols are treated as extdefs */
+      /* We do this 'cause common C symbols are treated as extdefs.  */
     case coff_vis_ext_def:
     case coff_vis_ext_ref:
     case coff_vis_ext_def:
     case coff_vis_ext_ref:
-
       dsy.ename = symbol->name;
       break;
 
       dsy.ename = symbol->name;
       break;
 
@@ -1139,36 +1108,28 @@ walk_tree_symbol (sfile, section, symbol, nest)
       break;
 
     case coff_vis_int_def:
       break;
 
     case coff_vis_int_def:
-
     case coff_vis_auto:
     case coff_vis_register:
     case coff_vis_tag:
     case coff_vis_member_of_struct:
     case coff_vis_member_of_enum:
       break;
     case coff_vis_auto:
     case coff_vis_register:
     case coff_vis_tag:
     case coff_vis_member_of_struct:
     case coff_vis_member_of_enum:
       break;
+
     default:
     default:
-      abort ();
+      fatal (_("Unrecognised coff symbol visibility: %d"), symbol->visible->type);
     }
 
   dsy.sfn = 0;
   dsy.sln = 2;
     }
 
   dsy.sfn = 0;
   dsy.sln = 2;
-
   dsy.neg = 0x1001;
 
   dsy.neg = 0x1001;
 
-
   sysroff_swap_dsy_out (file, &dsy);
 
   walk_tree_type (sfile, symbol, symbol->type, nest);
 }
 
   sysroff_swap_dsy_out (file, &dsy);
 
   walk_tree_type (sfile, symbol, symbol->type, nest);
 }
 
-
 static void
 static void
-walk_tree_scope (section, sfile, scope, nest, type)
-     struct coff_section *section;
-     struct coff_sfile *sfile;
-     struct coff_scope *scope;
-     int nest;
-     int type;
+walk_tree_scope (struct coff_section *section, struct coff_sfile *sfile, struct coff_scope *scope, int nest, int type)
 {
   struct coff_symbol *vars;
   struct coff_scope *child;
 {
   struct coff_symbol *vars;
   struct coff_scope *child;
@@ -1182,57 +1143,43 @@ walk_tree_scope (section, sfile, scope, nest, type)
        wr_globals (tree, sfile, nest + 1);
 
       for (vars = scope->vars_head; vars; vars = vars->next)
        wr_globals (tree, sfile, nest + 1);
 
       for (vars = scope->vars_head; vars; vars = vars->next)
-       {
-         walk_tree_symbol (sfile, section, vars, nest);
-       }
+       walk_tree_symbol (sfile, section, vars, nest);
 
       for (child = scope->list_head; child; child = child->next)
 
       for (child = scope->list_head; child; child = child->next)
-       {
-         walk_tree_scope (section, sfile, child, nest + 1, BLOCK_TYPE_BLOCK);
-       }
+       walk_tree_scope (section, sfile, child, nest + 1, BLOCK_TYPE_BLOCK);
 
       wr_dps_end (section, scope, type);
     }
 }
 
       wr_dps_end (section, scope, type);
     }
 }
+
 static void
 static void
-walk_tree_sfile (section, sfile)
-     struct coff_section *section;
-     struct coff_sfile *sfile;
+walk_tree_sfile (struct coff_section *section, struct coff_sfile *sfile)
 {
   walk_tree_scope (section, sfile, sfile->scope, 0, BLOCK_TYPE_COMPUNIT);
 {
   walk_tree_scope (section, sfile, sfile->scope, 0, BLOCK_TYPE_COMPUNIT);
-
 }
 
 static void
 }
 
 static void
-wr_program_structure (p, sfile)
-     struct coff_ofile *p;
-     struct coff_sfile *sfile;
+wr_program_structure (struct coff_ofile *p, struct coff_sfile *sfile)
 {
 {
-
+  if (p->nsections < 4)
+    return;
   walk_tree_sfile (p->sections + 4, sfile);
   walk_tree_sfile (p->sections + 4, sfile);
-
 }
 
 static void
 }
 
 static void
-wr_du (p, sfile, n)
-     struct coff_ofile *p;
-     struct coff_sfile *sfile;
-     int n;
+wr_du (struct coff_ofile *p, struct coff_sfile *sfile, int n)
 {
   struct IT_du du;
   int lim;
 {
   struct IT_du du;
   int lim;
-#if 0
-  struct coff_symbol *symbol;
-  static int incit = 0x500000;
-  int used = 0;
-#endif
   int i;
   int j;
   unsigned int *lowest = (unsigned *) nints (p->nsections);
   unsigned int *highest = (unsigned *) nints (p->nsections);
   int i;
   int j;
   unsigned int *lowest = (unsigned *) nints (p->nsections);
   unsigned int *highest = (unsigned *) nints (p->nsections);
-  du.spare = 0;
-  du.format = abfd->flags & EXEC_P ? 0 : 1;
+
+  du.format = bfd_get_file_flags (abfd) & EXEC_P ? 0 : 1;
   du.optimized = 0;
   du.optimized = 0;
+  du.stackfrmt = 0;
+  du.spare = 0;
   du.unit = n;
   du.sections = p->nsections - 1;
   du.san = (int *) xcalloc (sizeof (int), du.sections);
   du.unit = n;
   du.sections = p->nsections - 1;
   du.san = (int *) xcalloc (sizeof (int), du.sections);
@@ -1245,54 +1192,14 @@ wr_du (p, sfile, n)
       highest[i] = 0;
     }
 
       highest[i] = 0;
     }
 
-  /* Look through all the symbols and try and work out the extents in this
-     source file */
-#if 0
-  for (symbol = sfile->scope->vars_head;
-       symbol;
-       symbol = symbol->next)
-    {
-      if (symbol->type->type == coff_secdef_type)
-       {
-         unsigned int low = symbol->where->offset;
-         unsigned int high = symbol->where->offset + symbol->type->size - 1;
-         struct coff_section *section = symbol->where->section;
-
-         int sn = section->number;
-         if (low < lowest[sn])
-           lowest[sn] = low;
-         if (high > highest[sn])
-           highest[sn] = high;
-       }
-    }
-
-
-  for (i = 0; i < du.sections; i++)
-    {
-      if (highest[i] == 0)
-       {
-         lowest[i] = highest[i] = incit;
-       }
-      du.san[used] = i;
-      du.length[used] = highest[i] - lowest[i];
-      du.address[used] = abfd->flags & EXEC_P ? lowest[i] : 0;
-      if (debug)
-       {
-         printf (" section %6s 0x%08x..0x%08x\n",
-                 p->sections[i + 1].name,
-                 lowest[i],
-                 highest[i]);
-       }
-      used++;
-    }
-
-#endif
   lim = du.sections;
   for (j = 0; j < lim; j++)
     {
       int src = j;
       int dst = j;
   lim = du.sections;
   for (j = 0; j < lim; j++)
     {
       int src = j;
       int dst = j;
+
       du.san[dst] = dst;
       du.san[dst] = dst;
+
       if (sfile->section[src].init)
        {
          du.length[dst]
       if (sfile->section[src].init)
        {
          du.length[dst]
@@ -1305,6 +1212,7 @@ wr_du (p, sfile, n)
          du.length[dst] = 0;
          du.address[dst] = 0;
        }
          du.length[dst] = 0;
          du.address[dst] = 0;
        }
+
       if (debug)
        {
          if (sfile->section[src].parent)
       if (debug)
        {
          if (sfile->section[src].parent)
@@ -1315,6 +1223,7 @@ wr_du (p, sfile, n)
                      du.address[dst] + du.length[dst] - 1);
            }
        }
                      du.address[dst] + du.length[dst] - 1);
            }
        }
+
       du.sections = dst + 1;
     }
 
       du.sections = dst + 1;
     }
 
@@ -1325,11 +1234,8 @@ wr_du (p, sfile, n)
 }
 
 static void
 }
 
 static void
-wr_dus (p, sfile)
-     struct coff_ofile *p;
-     struct coff_sfile *sfile;
+wr_dus (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_sfile *sfile)
 {
 {
-
   struct IT_dus dus;
 
   dus.efn = 0x1001;
   struct IT_dus dus;
 
   dus.efn = 0x1001;
@@ -1338,108 +1244,27 @@ wr_dus (p, sfile)
   dus.fname = (char **) xcalloc (sizeof (char *), dus.ns);
   dus.spare = nints (dus.ns);
   dus.ndir = 0;
   dus.fname = (char **) xcalloc (sizeof (char *), dus.ns);
   dus.spare = nints (dus.ns);
   dus.ndir = 0;
-  /* Find the filenames */
-#if 0
-  i = 0;
-
-  for (sfile = p->source_head;
-       sfile;
-       sfile = sfile->next)
-    {
-      dus.drb[i] = 0;
-      dus.spare[i] = 0;
-      dus.fname[i] = sfile->name;
-      i++;
-    }
-#else
+  /* Find the filenames.  */
   dus.drb[0] = 0;
   dus.fname[0] = sfile->name;
   dus.drb[0] = 0;
   dus.fname[0] = sfile->name;
-#endif
 
   sysroff_swap_dus_out (file, &dus);
 
 }
 
 /* Find the offset of the .text section for this sfile in the
 
   sysroff_swap_dus_out (file, &dus);
 
 }
 
 /* Find the offset of the .text section for this sfile in the
-   .text section for the output file */
+   .text section for the output file.  */
 
 static int
 
 static int
-find_base (sfile, section)
-     struct coff_sfile *sfile;
-     struct coff_section *section;
+find_base (struct coff_sfile *sfile, struct coff_section *section)
 {
   return sfile->section[section->number].low;
 }
 {
   return sfile->section[section->number].low;
 }
-static void
-wr_dln (p, sfile, n)
-     struct coff_ofile *p;
-     struct coff_sfile *sfile;
-     int n;
 
 
+static void
+wr_dln (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_sfile *sfile,
+       int n ATTRIBUTE_UNUSED)
 {
 {
-#if 0
-  if (n == 0)
-    {
-      /* Count up all the linenumbers */
-      struct coff_symbol *sy;
-      int lc = 0;
-      struct IT_dln dln;
-
-      int idx;
-
-      for (sy = p->symbol_list_head;
-          sy;
-          sy = sy->next_in_ofile_list)
-       {
-         struct coff_type *t = sy->type;
-         if (t->type == coff_function_type)
-           {
-             struct coff_line *l = t->u.function.lines;
-             lc += l->nlines;
-           }
-       }
-
-      dln.sfn = nints (lc);
-      dln.sln = nints (lc);
-      dln.lln = nints (lc);
-      dln.section = nints (lc);
-
-      dln.from_address = nints (lc);
-      dln.to_address = nints (lc);
-
-
-      dln.neg = 0x1001;
-
-      dln.nln = lc;
-
-      /* Run through once more and fill up the structure */
-      idx = 0;
-      for (sy = p->symbol_list_head;
-          sy;
-          sy = sy->next_in_ofile_list)
-       {
-         if (sy->type->type == coff_function_type)
-           {
-             int i;
-             struct coff_line *l = sy->type->u.function.lines;
-             for (i = 0; i < l->nlines; i++)
-               {
-                 dln.section[idx] = sy->where->section->number;
-                 dln.sfn[idx] = n;
-                 dln.sln[idx] = l->lines[i];
-                 dln.from_address[idx] = l->addresses[i];
-                 if (idx)
-                   dln.to_address[idx - 1] = dln.from_address[idx];
-                 idx++;
-               }
-           }
-         n++;
-       }
-      sysroff_swap_dln_out (file, &dln);
-    }
-
-#endif
-#if 1
   /* Count up all the linenumbers */
 
   struct coff_symbol *sy;
   /* Count up all the linenumbers */
 
   struct coff_symbol *sy;
@@ -1506,17 +1331,16 @@ wr_dln (p, sfile, n)
     }
   if (lc)
     sysroff_swap_dln_out (file, &dln);
     }
   if (lc)
     sysroff_swap_dln_out (file, &dln);
-#endif
 }
 
 }
 
-/* Write the global symbols out to the debug info */
+/* Write the global symbols out to the debug info.  */
+
 static void
 static void
-wr_globals (p, sfile, n)
-     struct coff_ofile *p;
-     struct coff_sfile *sfile;
-     int n;
+wr_globals (struct coff_ofile *p, struct coff_sfile *sfile,
+           int n ATTRIBUTE_UNUSED)
 {
   struct coff_symbol *sy;
 {
   struct coff_symbol *sy;
+
   for (sy = p->symbol_list_head;
        sy;
        sy = sy->next_in_ofile_list)
   for (sy = p->symbol_list_head;
        sy;
        sy = sy->next_in_ofile_list)
@@ -1525,29 +1349,26 @@ wr_globals (p, sfile, n)
          || sy->visible->type == coff_vis_ext_ref)
        {
          /* Only write out symbols if they belong to
          || sy->visible->type == coff_vis_ext_ref)
        {
          /* Only write out symbols if they belong to
-            the current source file */
+            the current source file.  */
          if (sy->sfile == sfile)
            walk_tree_symbol (sfile, 0, sy, 0);
          if (sy->sfile == sfile)
            walk_tree_symbol (sfile, 0, sy, 0);
-
        }
     }
 }
 
 static void
        }
     }
 }
 
 static void
-wr_debug (p)
-     struct coff_ofile *p;
+wr_debug (struct coff_ofile *p)
 {
   struct coff_sfile *sfile;
   int n = 0;
 {
   struct coff_sfile *sfile;
   int n = 0;
+
   for (sfile = p->source_head;
        sfile;
        sfile = sfile->next)
   for (sfile = p->source_head;
        sfile;
        sfile = sfile->next)
-
     {
       if (debug)
     {
       if (debug)
-       {
-         printf ("%s\n", sfile->name);
-       }
+       printf ("%s\n", sfile->name);
+
       wr_du (p, sfile, n);
       wr_dus (p, sfile);
       wr_program_structure (p, sfile);
       wr_du (p, sfile, n);
       wr_dus (p, sfile);
       wr_program_structure (p, sfile);
@@ -1557,25 +1378,26 @@ wr_debug (p)
 }
 
 static void
 }
 
 static void
-wr_cs ()
+wr_cs (void)
 {
   /* It seems that the CS struct is not normal - the size is wrong
 {
   /* It seems that the CS struct is not normal - the size is wrong
-     heres one I prepared earlier.. */
-  static char b[] = {
+     heres one I prepared earlier.  */
+  static char b[] =
+    {
     0x80,                      /* IT */
     0x21,                      /* RL */
     0x00,                      /* number of chars in variable length part */
     0x80,                      /* IT */
     0x21,                      /* RL */
     0x00,                      /* number of chars in variable length part */
-    0x80,                      /* hd */ 
-    0x00,                      /* hs */ 
-    0x80,                      /* un */ 
-    0x00,                      /* us */ 
-    0x80,                      /* sc */ 
-    0x00,                      /* ss */ 
-    0x80,                      /* er */ 
-    0x80,                      /* ed */ 
-    0x80,                      /* sh */ 
-    0x80,                      /* ob */ 
-    0x80,                      /* rl */ 
+    0x80,                      /* hd */
+    0x00,                      /* hs */
+    0x80,                      /* un */
+    0x00,                      /* us */
+    0x80,                      /* sc */
+    0x00,                      /* ss */
+    0x80,                      /* er */
+    0x80,                      /* ed */
+    0x80,                      /* sh */
+    0x80,                      /* ob */
+    0x80,                      /* rl */
     0x80,                      /* du */
     0x80,                      /* dps */
     0x80,                      /* dsy */
     0x80,                      /* du */
     0x80,                      /* dps */
     0x80,                      /* dsy */
@@ -1596,36 +1418,33 @@ wr_cs ()
     0x00,                      /* dot */
     0xDE                       /* CS */
   };
     0x00,                      /* dot */
     0xDE                       /* CS */
   };
-  fwrite (b, 1, sizeof (b), file);
+
+  if (fwrite (b, sizeof (b), 1, file) != 1)
+    /* FIXME: Return error status.  */
+    fatal (_("Failed to write CS struct"));
 }
 
 /* Write out the SC records for a unit.  Create an SC
    for all the sections which appear in the output file, even
 }
 
 /* Write out the SC records for a unit.  Create an SC
    for all the sections which appear in the output file, even
-   if there isn't an equivalent one on the input */
+   if there isn't an equivalent one on the input.  */
 
 static int
 
 static int
-wr_sc (ptr, sfile)
-     struct coff_ofile *ptr;
-     struct coff_sfile *sfile;
+wr_sc (struct coff_ofile *ptr, struct coff_sfile *sfile)
 {
   int i;
 {
   int i;
-int scount = 0;
-  /* First work out the total number of sections */
-
+  int scount = 0;
+  /* First work out the total number of sections.  */
   int total_sec = ptr->nsections;
   int total_sec = ptr->nsections;
-
   struct myinfo
     {
       struct coff_section *sec;
       struct coff_symbol *symbol;
     };
   struct coff_symbol *symbol;
   struct myinfo
     {
       struct coff_section *sec;
       struct coff_symbol *symbol;
     };
   struct coff_symbol *symbol;
-
   struct myinfo *info
     = (struct myinfo *) calloc (total_sec, sizeof (struct myinfo));
 
 
   struct myinfo *info
     = (struct myinfo *) calloc (total_sec, sizeof (struct myinfo));
 
 
-
   for (i = 0; i < total_sec; i++)
     {
       info[i].sec = ptr->sections + i;
   for (i = 0; i < total_sec; i++)
     {
       info[i].sec = ptr->sections + i;
@@ -1651,27 +1470,28 @@ int scount = 0;
     }
 
   /* Now output all the section info, and fake up some stuff for sections
     }
 
   /* Now output all the section info, and fake up some stuff for sections
-     we don't have */
-
+     we don't have.  */
   for (i = 1; i < total_sec; i++)
     {
       struct IT_sc sc;
       char *name;
   for (i = 1; i < total_sec; i++)
     {
       struct IT_sc sc;
       char *name;
+
       symbol = info[i].symbol;
       sc.spare = 0;
       sc.spare1 = 0;
       symbol = info[i].symbol;
       sc.spare = 0;
       sc.spare1 = 0;
+
       if (!symbol)
        {
       if (!symbol)
        {
-         /* Don't have a symbol set aside for this section, which means that nothing
-            in this file does anything for the section. */
-         sc.format = !(abfd->flags & EXEC_P);
+         /* Don't have a symbol set aside for this section, which means
+            that nothing in this file does anything for the section.  */
+         sc.format = !(bfd_get_file_flags (abfd) & EXEC_P);
          sc.addr = 0;
          sc.length = 0;
          name = info[i].sec->name;
        }
       else
        {
          sc.addr = 0;
          sc.length = 0;
          name = info[i].sec->name;
        }
       else
        {
-         if (abfd->flags & EXEC_P)
+         if (bfd_get_file_flags (abfd) & EXEC_P)
            {
              sc.format = 0;
              sc.addr = symbol->where->offset;
            {
              sc.format = 0;
              sc.addr = symbol->where->offset;
@@ -1686,7 +1506,6 @@ int scount = 0;
        }
 
       sc.align = 4;
        }
 
       sc.align = 4;
-
       sc.concat = CONCAT_SIMPLE;
       sc.read = 3;
       sc.write = 3;
       sc.concat = CONCAT_SIMPLE;
       sc.read = 3;
       sc.write = 3;
@@ -1695,8 +1514,9 @@ int scount = 0;
       sc.mode = 3;
       sc.spare = 0;
       sc.segadd = 0;
       sc.mode = 3;
       sc.spare = 0;
       sc.segadd = 0;
-      sc.spare1 = 0;           /* If not zero, then it doesn't work */
+      sc.spare1 = 0;           /* If not zero, then it doesn't work.  */
       sc.name = section_translate (name);
       sc.name = section_translate (name);
+
       if (strlen (sc.name) == 1)
        {
          switch (sc.name[0])
       if (strlen (sc.name) == 1)
        {
          switch (sc.name[0])
@@ -1705,6 +1525,7 @@ int scount = 0;
            case 'B':
              sc.contents = CONTENTS_DATA;
              break;
            case 'B':
              sc.contents = CONTENTS_DATA;
              break;
+
            default:
              sc.contents = CONTENTS_CODE;
            }
            default:
              sc.contents = CONTENTS_CODE;
            }
@@ -1713,25 +1534,23 @@ int scount = 0;
        {
          sc.contents = CONTENTS_CODE;
        }
        {
          sc.contents = CONTENTS_CODE;
        }
-      /* NEW */
-      if (sc.length) {
-       sysroff_swap_sc_out (file, &sc);
-       scount++;
-      }
+
+      sysroff_swap_sc_out (file, &sc);
+      scount++;
     }
     }
-return scount;
+  free (info);
+  return scount;
 }
 
 }
 
+/* Write out the ER records for a unit.  */
 
 
-/* Write out the ER records for a unit. */
 static void
 static void
-wr_er (ptr, sfile, first)
-     struct coff_ofile *ptr;
-     struct coff_sfile *sfile;
-     int first;
+wr_er (struct coff_ofile *ptr, struct coff_sfile *sfile ATTRIBUTE_UNUSED,
+       int first)
 {
   int idx = 0;
   struct coff_symbol *sym;
 {
   int idx = 0;
   struct coff_symbol *sym;
+
   if (first)
     {
       for (sym = ptr->symbol_list_head; sym; sym = sym->next_in_ofile_list)
   if (first)
     {
       for (sym = ptr->symbol_list_head; sym; sym = sym->next_in_ofile_list)
@@ -1739,6 +1558,7 @@ wr_er (ptr, sfile, first)
          if (sym->visible->type == coff_vis_ext_ref)
            {
              struct IT_er er;
          if (sym->visible->type == coff_vis_ext_ref)
            {
              struct IT_er er;
+
              er.spare = 0;
              er.type = ER_NOTSPEC;
              er.name = sym->name;
              er.spare = 0;
              er.type = ER_NOTSPEC;
              er.name = sym->name;
@@ -1749,14 +1569,14 @@ wr_er (ptr, sfile, first)
     }
 }
 
     }
 }
 
-/* Write out the ED records for a unit. */
+/* Write out the ED records for a unit.  */
+
 static void
 static void
-wr_ed (ptr, sfile, first)
-     struct coff_ofile *ptr;
-     struct coff_sfile *sfile;
-     int first;
+wr_ed (struct coff_ofile *ptr, struct coff_sfile *sfile ATTRIBUTE_UNUSED,
+       int first)
 {
   struct coff_symbol *s;
 {
   struct coff_symbol *s;
+
   if (first)
     {
       for (s = ptr->symbol_list_head; s; s = s->next_in_ofile_list)
   if (first)
     {
       for (s = ptr->symbol_list_head; s; s = s->next_in_ofile_list)
@@ -1768,6 +1588,7 @@ wr_ed (ptr, sfile, first)
 
              ed.section = s->where->section->number;
              ed.spare = 0;
 
              ed.section = s->where->section->number;
              ed.spare = 0;
+
              if (s->where->section->data)
                {
                  ed.type = ED_TYPE_DATA;
              if (s->where->section->data)
                {
                  ed.type = ED_TYPE_DATA;
@@ -1781,6 +1602,7 @@ wr_ed (ptr, sfile, first)
                  ed.type = ED_TYPE_NOTSPEC;
                  ed.type = ED_TYPE_DATA;
                }
                  ed.type = ED_TYPE_NOTSPEC;
                  ed.type = ED_TYPE_DATA;
                }
+
              ed.address = s->where->offset - s->where->section->address;
              ed.name = s->name;
              sysroff_swap_ed_out (file, &ed);
              ed.address = s->where->offset - s->where->section->address;
              ed.name = s->name;
              sysroff_swap_ed_out (file, &ed);
@@ -1790,11 +1612,11 @@ wr_ed (ptr, sfile, first)
 }
 
 static void
 }
 
 static void
-wr_unit_info (ptr)
-     struct coff_ofile *ptr;
+wr_unit_info (struct coff_ofile *ptr)
 {
   struct coff_sfile *sfile;
   int first = 1;
 {
   struct coff_sfile *sfile;
   int first = 1;
+
   for (sfile = ptr->source_head;
        sfile;
        sfile = sfile->next)
   for (sfile = ptr->source_head;
        sfile;
        sfile = sfile->next)
@@ -1802,13 +1624,14 @@ wr_unit_info (ptr)
       long p1;
       long p2;
       int nsecs;
       long p1;
       long p2;
       int nsecs;
+
       p1 = ftell (file);
       wr_un (ptr, sfile, first, 0);
       nsecs = wr_sc (ptr, sfile);
       p2 = ftell (file);
       fseek (file, p1, SEEK_SET);
       wr_un (ptr, sfile, first, nsecs);
       p1 = ftell (file);
       wr_un (ptr, sfile, first, 0);
       nsecs = wr_sc (ptr, sfile);
       p2 = ftell (file);
       fseek (file, p1, SEEK_SET);
       wr_un (ptr, sfile, first, nsecs);
-      fseek (file, p2, SEEK_SET); 
+      fseek (file, p2, SEEK_SET);
       wr_er (ptr, sfile, first);
       wr_ed (ptr, sfile, first);
       first = 0;
       wr_er (ptr, sfile, first);
       wr_ed (ptr, sfile, first);
       first = 0;
@@ -1816,8 +1639,7 @@ wr_unit_info (ptr)
 }
 
 static void
 }
 
 static void
-wr_module (p)
-     struct coff_ofile *p;
+wr_module (struct coff_ofile *p)
 {
   wr_cs ();
   wr_hd (p);
 {
   wr_cs ();
   wr_hd (p);
@@ -1828,24 +1650,27 @@ wr_module (p)
 }
 
 static int
 }
 
 static int
-align (x)
-     int x;
+align (int x)
 {
   return (x + 3) & ~3;
 }
 
 /* Find all the common variables and turn them into
 {
   return (x + 3) & ~3;
 }
 
 /* Find all the common variables and turn them into
-   ordinary defs - dunno why, but thats what hitachi does with 'em */
+   ordinary defs - dunno why, but thats what hitachi does with 'em.  */
 
 static void
 
 static void
-prescan (tree)
-     struct coff_ofile *tree;
+prescan (struct coff_ofile *otree)
 {
   struct coff_symbol *s;
   struct coff_section *common_section;
 {
   struct coff_symbol *s;
   struct coff_section *common_section;
-  /* Find the common section - always section 3 */
-  common_section = tree->sections + 3;
-  for (s = tree->symbol_list_head;
+
+  if (otree->nsections < 3)
+    return;
+
+  /* Find the common section - always section 3.  */
+  common_section = otree->sections + 3;
+
+  for (s = otree->symbol_list_head;
        s;
        s = s->next_in_ofile_list)
     {
        s;
        s = s->next_in_ofile_list)
     {
@@ -1864,29 +1689,26 @@ prescan (tree)
 
 char *program_name;
 
 
 char *program_name;
 
-static void
-show_usage (file, status)
-     FILE *file;
-     int status;
+ATTRIBUTE_NORETURN static void
+show_usage (FILE *ffile, int status)
 {
 {
-  fprintf (file, "Usage: %s [-dhVq] in-file [out-file]\n", program_name);
+  fprintf (ffile, _("Usage: %s [option(s)] in-file [out-file]\n"), program_name);
+  fprintf (ffile, _("Convert a COFF object file into a SYSROFF object file\n"));
+  fprintf (ffile, _(" The options are:\n\
+  -q --quick       (Obsolete - ignored)\n\
+  -n --noprescan   Do not perform a scan to convert commons into defs\n\
+  -d --debug       Display information about what is being done\n\
+  @<file>          Read options from <file>\n\
+  -h --help        Display this information\n\
+  -v --version     Print the program's version number\n"));
+
+  if (REPORT_BUGS_TO[0] && status == 0)
+    fprintf (ffile, _("Report bugs to %s\n"), REPORT_BUGS_TO);
   exit (status);
 }
 
   exit (status);
 }
 
-static void
-show_help ()
-{
-  printf ("%s: Convert a COFF object file into a SYSROFF object file\n",
-         program_name);
-  show_usage (stdout, 0);
-}
-
-
-
 int
 int
-main (ac, av)
-     int ac;
-     char *av[];
+main (int ac, char **av)
 {
   int opt;
   static struct option long_options[] =
 {
   int opt;
   static struct option long_options[] =
@@ -1900,12 +1722,24 @@ main (ac, av)
   };
   char **matching;
   char *input_file;
   };
   char **matching;
   char *input_file;
-
   char *output_file;
   char *output_file;
+
+#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
+  setlocale (LC_MESSAGES, "");
+#endif
+#if defined (HAVE_SETLOCALE)
+  setlocale (LC_CTYPE, "");
+#endif
+  bindtextdomain (PACKAGE, LOCALEDIR);
+  textdomain (PACKAGE);
+
   program_name = av[0];
   xmalloc_set_program_name (program_name);
   program_name = av[0];
   xmalloc_set_program_name (program_name);
+  bfd_set_error_program_name (program_name);
 
 
-  while ((opt = getopt_long (ac, av, "dhVqn", long_options,
+  expandargv (&ac, &av);
+
+  while ((opt = getopt_long (ac, av, "dHhVvqn", long_options,
                             (int *) NULL))
         != EOF)
     {
                             (int *) NULL))
         != EOF)
     {
@@ -1920,11 +1754,13 @@ main (ac, av)
        case 'd':
          debug = 1;
          break;
        case 'd':
          debug = 1;
          break;
+       case 'H':
        case 'h':
        case 'h':
-         show_help ();
+         show_usage (stdout, 0);
          /*NOTREACHED */
          /*NOTREACHED */
+       case 'v':
        case 'V':
        case 'V':
-         printf ("GNU %s version %s\n", program_name, PROGRAM_VERSION);
+         print_version ("srconv");
          exit (0);
          /*NOTREACHED */
        case 0:
          exit (0);
          /*NOTREACHED */
        case 0:
@@ -1947,12 +1783,9 @@ main (ac, av)
          ++optind;
          if (optind < ac)
            show_usage (stderr, 1);
          ++optind;
          if (optind < ac)
            show_usage (stderr, 1);
-         if (strcmp (input_file, output_file) == 0)
+         if (filename_cmp (input_file, output_file) == 0)
            {
            {
-             fprintf (stderr,
-                      "%s: input and output files must be different\n",
-                      program_name);
-             exit (1);
+             fatal (_("input and output files must be different"));
            }
        }
     }
            }
        }
     }
@@ -1961,9 +1794,7 @@ main (ac, av)
 
   if (!input_file)
     {
 
   if (!input_file)
     {
-      fprintf (stderr, "%s: no input file specified\n",
-              program_name);
-      exit (1);
+      fatal (_("no input file specified"));
     }
 
   if (!output_file)
     }
 
   if (!output_file)
@@ -1972,8 +1803,10 @@ main (ac, av)
          it doesn't end in .o, then stick a .obj on anyway */
 
       int len = strlen (input_file);
          it doesn't end in .o, then stick a .obj on anyway */
 
       int len = strlen (input_file);
+
       output_file = xmalloc (len + 5);
       strcpy (output_file, input_file);
       output_file = xmalloc (len + 5);
       strcpy (output_file, input_file);
+
       if (len > 3
          && output_file[len - 2] == '.'
          && output_file[len - 1] == 'o')
       if (len > 3
          && output_file[len - 2] == '.'
          && output_file[len - 1] == 'o')
@@ -1996,6 +1829,7 @@ main (ac, av)
   if (!bfd_check_format_matches (abfd, bfd_object, &matching))
     {
       bfd_nonfatal (input_file);
   if (!bfd_check_format_matches (abfd, bfd_object, &matching))
     {
       bfd_nonfatal (input_file);
+
       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
        {
          list_matching_formats (matching);
       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
        {
          list_matching_formats (matching);
@@ -2007,17 +1841,18 @@ main (ac, av)
   file = fopen (output_file, FOPEN_WB);
 
   if (!file)
   file = fopen (output_file, FOPEN_WB);
 
   if (!file)
-    {
-      fprintf (stderr, "%s: unable to open output file %s\n",
-              program_name, output_file);
-      exit (1);
-    }
+    fatal (_("unable to open output file %s"), output_file);
 
   if (debug)
     printf ("ids %d %d\n", base1, base2);
 
   if (debug)
     printf ("ids %d %d\n", base1, base2);
+
   tree = coff_grok (abfd);
   tree = coff_grok (abfd);
-  if (!noprescan)
-    prescan (tree);
-  wr_module (tree);
+  if (tree)
+    {
+      if (!noprescan)
+       prescan (tree);
+
+      wr_module (tree);
+    }
   return 0;
 }
   return 0;
 }
GDB Binutils - Deliverables
This page took 0.046586 seconds and 4 git commands to generate.