Fix bugs and remove compile time warnings for N"32K port.
authorNick Clifton <nickc@redhat.com>
Wed, 31 Jul 2002 16:23:29 +0000 (16:23 +0000)
committerNick Clifton <nickc@redhat.com>
Wed, 31 Jul 2002 16:23:29 +0000 (16:23 +0000)
bfd/ChangeLog
bfd/aout-ns32k.c
bfd/cpu-ns32k.c
bfd/ns32k.h
gas/ChangeLog
gas/config/tc-ns32k.c
gas/config/tc-ns32k.h

index 9052b64..9b624e4 100644 (file)
@@ -5,6 +5,22 @@
 
 2002-07-31  Ian Dall  <ian@sibyl.beware.dropbear.id.au>
 
+       * cpu-ns32k.c (_bfd_ns32k_put_immdeiate, _bfd_ns32k_get_immediate):
+       There is no 8 byte relocation type for this architecture.
+       (do_ns32k_reloc): Use bfd_vma instead of native types.
+       (bfd_ns32k_put_immediate, _bfd_ns32k_relocate_contents) put_data
+       returns void.
+       (_bfd_ns32k_put_displacement): Don't check for overflow. We can
+       rely on generic code to do that.
+       * aout-ns32k.c (howto_table): Add appropriate overflow detection
+       to all table entries.
+       (_bfd_ns32k_relocate_contents): put_data returns void.
+       * ns32k.h: (_bfd_ns32k_put_displacement, _bfd_ns32k_put_immediate)
+       (_bfd_do_ns32k_reloc_contents): Fix prototypes. put data functions
+       return void.
+
+2002-07-31  Ian Dall  <ian@sibyl.beware.dropbear.id.au>
+
        * aoutx.h (aout_link_check_ar_symbols): Whether to include an
        archive object is target dependant.
 
index e16388b..8456e80 100644 (file)
@@ -1,23 +1,23 @@
 /* BFD back-end for ns32k a.out-ish binaries.
-   Copyright 1990, 1991, 1992, 1994, 1995, 1996, 1998, 2000, 2001
+   Copyright 1990, 1991, 1992, 1994, 1995, 1996, 1998, 2000, 2001, 2002
    Free Software Foundation, Inc.
    Contributed by Ian Dall (idall@eleceng.adelaide.edu.au).
 
-This file is part of BFD, the Binary File Descriptor library.
+   This file is part of BFD, the Binary File Descriptor library.
 
-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
-(at your option) any later version.
+   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
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-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.  */
+   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.  */
 
 #define BYTES_IN_WORD 4
 
@@ -49,16 +49,16 @@ void bfd_ns32k_arch PARAMS ((void));
 
 #define MY(OP) MYNS(OP)
 
-#define MY_swap_std_reloc_in MY(swap_std_reloc_in)
+#define MY_swap_std_reloc_in  MY(swap_std_reloc_in)
 #define MY_swap_std_reloc_out MY(swap_std_reloc_out)
 
 static void
-MY_swap_std_reloc_in PARAMS ((bfd *abfd, struct reloc_std_external *bytes,
-                             arelent *cache_ptr, asymbol **symbols,
-                             bfd_size_type symcount));
+MY_swap_std_reloc_in PARAMS ((bfd *, struct reloc_std_external *,
+                             arelent *, asymbol **,
+                             bfd_size_type));
 static void
-MY_swap_std_reloc_out PARAMS ((bfd *abfd, arelent *g,
-                              struct reloc_std_external *natptr));
+MY_swap_std_reloc_out PARAMS ((bfd *, arelent *,
+                              struct reloc_std_external *));
 reloc_howto_type *
 MY(reloc_howto) PARAMS ((bfd *, struct reloc_std_external *,
                         int *, int *, int *));
@@ -94,47 +94,48 @@ MY(put_reloc) PARAMS ((bfd *, int, int, bfd_vma, reloc_howto_type *,
 
    In addition, for historical reasons the encoding of the relocation types
    in the a.out format relocation entries is such that even the relocation
-   methods which are standard are not encoded the standard way. */
+   methods which are standard are not encoded the standard way.  */
 
 reloc_howto_type MY(howto_table)[] =
   {
+    /* type           rs   size bsz  pcrel bitpos ovrf                  sf name          part_inpl readmask setmask pcdone */
     /* ns32k immediate operands.  */
-    HOWTO (BFD_RELOC_NS32K_IMM_8, 0, 0, 8, false, 0, true,
+    HOWTO (BFD_RELOC_NS32K_IMM_8, 0, 0, 8, false, 0, complain_overflow_signed,
           _bfd_ns32k_reloc_imm, "NS32K_IMM_8",
           true, 0x000000ff,0x000000ff, false),
-    HOWTO (BFD_RELOC_NS32K_IMM_16, 0, 1, 16, false, 0, true,
+    HOWTO (BFD_RELOC_NS32K_IMM_16, 0, 1, 16, false, 0, complain_overflow_signed,
           _bfd_ns32k_reloc_imm,  "NS32K_IMM_16",
           true, 0x0000ffff,0x0000ffff, false),
-    HOWTO (BFD_RELOC_NS32K_IMM_32, 0, 2, 32, false, 0, true,
+    HOWTO (BFD_RELOC_NS32K_IMM_32, 0, 2, 32, false, 0, complain_overflow_signed,
           _bfd_ns32k_reloc_imm, "NS32K_IMM_32",
           true, 0xffffffff,0xffffffff, false),
-    HOWTO (BFD_RELOC_NS32K_IMM_8_PCREL, 0, 0, 8, true, 0, false,
+    HOWTO (BFD_RELOC_NS32K_IMM_8_PCREL, 0, 0, 8, true, 0, complain_overflow_signed,
           _bfd_ns32k_reloc_imm, "PCREL_NS32K_IMM_8",
           true, 0x000000ff, 0x000000ff, false),
-    HOWTO (BFD_RELOC_NS32K_IMM_16_PCREL, 0, 1, 16, true, 0, false,
+    HOWTO (BFD_RELOC_NS32K_IMM_16_PCREL, 0, 1, 16, true, 0, complain_overflow_signed,
           _bfd_ns32k_reloc_imm, "PCREL_NS32K_IMM_16",
           true, 0x0000ffff,0x0000ffff, false),
-    HOWTO (BFD_RELOC_NS32K_IMM_32_PCREL, 0, 2, 32, true, 0, false,
+    HOWTO (BFD_RELOC_NS32K_IMM_32_PCREL, 0, 2, 32, true, 0, complain_overflow_signed,
           _bfd_ns32k_reloc_imm, "PCREL_NS32K_IMM_32",
           true, 0xffffffff,0xffffffff, false),
 
     /* ns32k displacements.  */
-    HOWTO (BFD_RELOC_NS32K_DISP_8, 0, 0, 8, false, 0, true,
+    HOWTO (BFD_RELOC_NS32K_DISP_8, 0, 0, 7, false, 0, complain_overflow_signed,
           _bfd_ns32k_reloc_disp, "NS32K_DISP_8",
           true, 0x000000ff,0x000000ff, false),
-    HOWTO (BFD_RELOC_NS32K_DISP_16, 0, 1, 16, false, 0, true,
+    HOWTO (BFD_RELOC_NS32K_DISP_16, 0, 1, 14, false, 0, complain_overflow_signed,
           _bfd_ns32k_reloc_disp, "NS32K_DISP_16",
           true, 0x0000ffff, 0x0000ffff, false),
-    HOWTO (BFD_RELOC_NS32K_DISP_32, 0, 2, 32, false, 0, true,
+    HOWTO (BFD_RELOC_NS32K_DISP_32, 0, 2, 30, false, 0, complain_overflow_signed,
           _bfd_ns32k_reloc_disp, "NS32K_DISP_32",
           true, 0xffffffff, 0xffffffff, false),
-    HOWTO (BFD_RELOC_NS32K_DISP_8_PCREL, 0, 0, 8, true, 0, false,
+    HOWTO (BFD_RELOC_NS32K_DISP_8_PCREL, 0, 0, 7, true, 0, complain_overflow_signed,
           _bfd_ns32k_reloc_disp, "PCREL_NS32K_DISP_8",
           true, 0x000000ff,0x000000ff, false),
-    HOWTO (BFD_RELOC_NS32K_DISP_16_PCREL, 0, 1, 16, true, 0, false,
+    HOWTO (BFD_RELOC_NS32K_DISP_16_PCREL, 0, 1, 14, true, 0, complain_overflow_signed,
           _bfd_ns32k_reloc_disp, "PCREL_NS32K_DISP_16",
           true, 0x0000ffff,0x0000ffff, false),
-    HOWTO (BFD_RELOC_NS32K_DISP_32_PCREL, 0, 2, 32, true, 0, false,
+    HOWTO (BFD_RELOC_NS32K_DISP_32_PCREL, 0, 2, 30, true, 0, complain_overflow_signed,
           _bfd_ns32k_reloc_disp, "PCREL_NS32K_DISP_32",
           true, 0xffffffff,0xffffffff, false),
 
@@ -355,7 +356,7 @@ _bfd_ns32k_relocate_contents (howto, input_bfd, relocation, location)
 {
   int r_ns32k_type = (howto - MY(howto_table)) / 6;
   bfd_vma (*get_data) PARAMS ((bfd_byte *, int));
-  int (*put_data) PARAMS ((bfd_vma, bfd_byte *, int));
+  void (*put_data) PARAMS ((bfd_vma, bfd_byte *, int));
 
   switch (r_ns32k_type)
     {
index f0059d5..acc081a 100644 (file)
@@ -4,21 +4,21 @@
    Almost totally rewritten by Ian Dall from initial work
    by Andrew Cagney.
 
-This file is part of BFD, the Binary File Descriptor library.
+   This file is part of BFD, the Binary File Descriptor library.
 
-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
-(at your option) any later version.
+   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
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-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.  */
+   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.  */
 
 #include "bfd.h"
 #include "sysdep.h"
@@ -30,7 +30,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 static const bfd_arch_info_type arch_info_struct[] =
 {
-  N(32532,"ns32k:32532",true, 0), /* the word ns32k will match this too */
+  N(32532,"ns32k:32532",true, 0), /* The word ns32k will match this too.  */
 };
 
 const bfd_arch_info_type bfd_ns32k_arch =
@@ -40,7 +40,7 @@ static bfd_reloc_status_type do_ns32k_reloc
   PARAMS ((bfd *, arelent *, struct symbol_cache_entry *, PTR, asection *,
           bfd *, char **,
           bfd_vma (*) (bfd_byte *, int),
-          int (*) (bfd_vma, bfd_byte *, int)));
+          void (*) (bfd_vma, bfd_byte *, int)));
 
 bfd_vma
 _bfd_ns32k_get_displacement (buffer, size)
@@ -48,6 +48,7 @@ _bfd_ns32k_get_displacement (buffer, size)
      int size;
 {
   bfd_signed_vma value;
+
   switch (size)
     {
     case 1:
@@ -70,10 +71,11 @@ _bfd_ns32k_get_displacement (buffer, size)
       abort ();
       return 0;
     }
+
   return value;
 }
 
-int
+void
 _bfd_ns32k_put_displacement (value, buffer, size)
      bfd_vma value;
      bfd_byte *buffer;
@@ -82,15 +84,11 @@ _bfd_ns32k_put_displacement (value, buffer, size)
   switch (size)
     {
     case 1:
-      if (value + 0x40 > 0x7f)
-       return -1;
       value &= 0x7f;
       *buffer++ = value;
       break;
 
     case 2:
-      if (value + 0x2000 > 0x3fff)
-       return -1;
       value &= 0x3fff;
       value |= 0x8000;
       *buffer++ = (value >> 8);
@@ -98,19 +96,14 @@ _bfd_ns32k_put_displacement (value, buffer, size)
       break;
 
     case 4:
-      /* FIXME: is this correct?  -0x1f000000 <= value < 0x2000000 */
-      if (value + 0x1f000000 > 0x3effffff)
-       return -1;
       value |= (bfd_vma) 0xc0000000;
       *buffer++ = (value >> 24);
       *buffer++ = (value >> 16);
       *buffer++ = (value >> 8);
       *buffer++ = value;
       break;
-    default:
-      return -1;
   }
-  return 0;
+  return;
 }
 
 bfd_vma
@@ -119,13 +112,9 @@ _bfd_ns32k_get_immediate (buffer, size)
      int size;
 {
   bfd_vma value = 0;
+
   switch (size)
     {
-    case 8:
-      value = (value << 8) | (*buffer++ & 0xff);
-      value = (value << 8) | (*buffer++ & 0xff);
-      value = (value << 8) | (*buffer++ & 0xff);
-      value = (value << 8) | (*buffer++ & 0xff);
     case 4:
       value = (value << 8) | (*buffer++ & 0xff);
       value = (value << 8) | (*buffer++ & 0xff);
@@ -133,11 +122,14 @@ _bfd_ns32k_get_immediate (buffer, size)
       value = (value << 8) | (*buffer++ & 0xff);
     case 1:
       value = (value << 8) | (*buffer++ & 0xff);
+      break;
+    default:
+      abort ();
     }
   return value;
 }
 
-int
+void
 _bfd_ns32k_put_immediate (value, buffer, size)
      bfd_vma value;
      bfd_byte *buffer;
@@ -146,11 +138,6 @@ _bfd_ns32k_put_immediate (value, buffer, size)
   buffer += size - 1;
   switch (size)
     {
-    case 8:
-      *buffer-- = (value & 0xff); value >>= 8;
-      *buffer-- = (value & 0xff); value >>= 8;
-      *buffer-- = (value & 0xff); value >>= 8;
-      *buffer-- = (value & 0xff); value >>= 8;
     case 4:
       *buffer-- = (value & 0xff); value >>= 8;
       *buffer-- = (value & 0xff); value >>= 8;
@@ -159,14 +146,13 @@ _bfd_ns32k_put_immediate (value, buffer, size)
     case 1:
       *buffer-- = (value & 0xff); value >>= 8;
     }
-  return 0;
 }
 
 /* This is just like the standard perform_relocation except we
- * use get_data and put_data which know about the ns32k
- * storage methods.
- * This is probably a lot more complicated than it needs to be!
- */
+   use get_data and put_data which know about the ns32k storage
+   methods.  This is probably a lot more complicated than it
+   needs to be!  */
+
 static bfd_reloc_status_type
 do_ns32k_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
                error_message, get_data, put_data)
@@ -178,7 +164,7 @@ do_ns32k_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
      bfd *output_bfd;
      char **error_message ATTRIBUTE_UNUSED;
      bfd_vma (*get_data) PARAMS ((bfd_byte *, int));
-     int (*put_data) PARAMS ((bfd_vma, bfd_byte *, int));
+     void (*put_data) PARAMS ((bfd_vma, bfd_byte *, int));
 {
   int overflow = 0;
   bfd_vma relocation;
@@ -262,7 +248,6 @@ do_ns32k_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
         producing relocateable output it is not what the code
         actually does.  I don't want to change it, because it seems
         far too likely that something will break.  */
-
       relocation -=
        input_section->output_section->vma + input_section->output_offset;
 
@@ -299,71 +284,76 @@ do_ns32k_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
                 relocation with -r.  Removing the line below this comment
                 fixes that problem; see PR 2953.
 
-However, Ian wrote the following, regarding removing the line below,
-which explains why it is still enabled:  --djm
-
-If you put a patch like that into BFD you need to check all the COFF
-linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
-SCO); see coff_i386_reloc in coff-i386.c where I worked around the
-problem in a different way.  There may very well be a reason that the
-code works as it does.
-
-Hmmm.  The first obvious point is that bfd_perform_relocation should
-not have any tests that depend upon the flavour.  It's seem like
-entirely the wrong place for such a thing.  The second obvious point
-is that the current code ignores the reloc addend when producing
-relocateable output for COFF.  That's peculiar.  In fact, I really
-have no idea what the point of the line you want to remove is.
-
-A typical COFF reloc subtracts the old value of the symbol and adds in
-the new value to the location in the object file (if it's a pc
-relative reloc it adds the difference between the symbol value and the
-location).  When relocating we need to preserve that property.
-
-BFD handles this by setting the addend to the negative of the old
-value of the symbol.  Unfortunately it handles common symbols in a
-non-standard way (it doesn't subtract the old value) but that's a
-different story (we can't change it without losing backward
-compatibility with old object files) (coff-i386 does subtract the old
-value, to be compatible with existing coff-i386 targets, like SCO).
-
-So everything works fine when not producing relocateable output.  When
-we are producing relocateable output, logically we should do exactly
-what we do when not producing relocateable output.  Therefore, your
-patch is correct.  In fact, it should probably always just set
-reloc_entry->addend to 0 for all cases, since it is, in fact, going to
-add the value into the object file.  This won't hurt the COFF code,
-which doesn't use the addend; I'm not sure what it will do to other
-formats (the thing to check for would be whether any formats both use
-the addend and set partial_inplace).
-
-When I wanted to make coff-i386 produce relocateable output, I ran
-into the problem that you are running into: I wanted to remove that
-line.  Rather than risk it, I made the coff-i386 relocs use a special
-function; it's coff_i386_reloc in coff-i386.c.  The function
-specifically adds the addend field into the object file, knowing that
-bfd_perform_relocation is not going to.  If you remove that line, then
-coff-i386.c will wind up adding the addend field in twice.  It's
-trivial to fix; it just needs to be done.
-
-The problem with removing the line is just that it may break some
-working code.  With BFD it's hard to be sure of anything.  The right
-way to deal with this is simply to build and test at least all the
-supported COFF targets.  It should be straightforward if time and disk
-space consuming.  For each target:
-    1) build the linker
-    2) generate some executable, and link it using -r (I would
-       probably use paranoia.o and link against newlib/libc.a, which
-       for all the supported targets would be available in
-       /usr/cygnus/progressive/H-host/target/lib/libc.a).
-    3) make the change to reloc.c
-    4) rebuild the linker
-    5) repeat step 2
-    6) if the resulting object files are the same, you have at least
-       made it no worse
-    7) if they are different you have to figure out which version is
-       right
-*/
+                However, Ian wrote the following, regarding removing the line
+                below, which explains why it is still enabled:  --djm
+
+                If you put a patch like that into BFD you need to check all
+                the COFF linkers.  I am fairly certain that patch will break
+                coff-i386 (e.g., SCO); see coff_i386_reloc in coff-i386.c
+                where I worked around the problem in a different way.  There
+                may very well be a reason that the code works as it does.
+
+                Hmmm.  The first obvious point is that bfd_perform_relocation
+                should not have any tests that depend upon the flavour.  It's
+                seem like entirely the wrong place for such a thing.  The
+                second obvious point is that the current code ignores the
+                reloc addend when producing relocateable output for COFF.
+                That's peculiar.  In fact, I really have no idea what the
+                point of the line you want to remove is.
+
+                A typical COFF reloc subtracts the old value of the symbol
+                and adds in the new value to the location in the object file
+                (if it's a pc relative reloc it adds the difference between
+                the symbol value and the location).  When relocating we need
+                to preserve that property.
+
+                BFD handles this by setting the addend to the negative of the
+                old value of the symbol.  Unfortunately it handles common
+                symbols in a non-standard way (it doesn't subtract the old
+                value) but that's a different story (we can't change it
+                without losing backward compatibility with old object files)
+                (coff-i386 does subtract the old value, to be compatible with
+                existing coff-i386 targets, like SCO).
+
+                So everything works fine when not producing relocateable
+                output.  When we are producing relocateable output, logically
+                we should do exactly what we do when not producing
+                relocateable output.  Therefore, your patch is correct.  In
+                fact, it should probably always just set reloc_entry->addend
+                to 0 for all cases, since it is, in fact, going to add the
+                value into the object file.  This won't hurt the COFF code,
+                which doesn't use the addend; I'm not sure what it will do
+                to other formats (the thing to check for would be whether
+                any formats both use the addend and set partial_inplace).
+
+                When I wanted to make coff-i386 produce relocateable output,
+                I ran into the problem that you are running into: I wanted
+                to remove that line.  Rather than risk it, I made the
+                coff-i386 relocs use a special function; it's coff_i386_reloc
+                in coff-i386.c.  The function specifically adds the addend
+                field into the object file, knowing that bfd_perform_relocation
+                is not going to.  If you remove that line, then coff-i386.c
+                will wind up adding the addend field in twice.  It's trivial
+                to fix; it just needs to be done.
+
+                The problem with removing the line is just that it may break
+                some working code.  With BFD it's hard to be sure of anything.
+                The right way to deal with this is simply to build and test at
+                least all the supported COFF targets.  It should be
+                straightforward if time and disk space consuming.  For each
+                target:
+                  1) build the linker
+                  2) generate some executable, and link it using -r (I would
+                     probably use paranoia.o and link against newlib/libc.a,
+                     which for all the supported targets would be available in
+                     /usr/cygnus/progressive/H-host/target/lib/libc.a).
+                  3) make the change to reloc.c
+                  4) rebuild the linker
+                  5) repeat step 2
+                  6) if the resulting object files are the same, you have at
+                     least made it no worse
+                  7) if they are different you have to figure out which
+                     version is right.  */
              relocation -= reloc_entry->addend;
 #endif
              reloc_entry->addend = 0;
@@ -462,11 +452,9 @@ space consuming.  For each target:
        }
     }
 
-  /*
-    Either we are relocating all the way, or we don't want to apply
-    the relocation to the reloc entry (probably because there isn't
-    any room in the output format to describe addends to relocs)
-    */
+  /* Either we are relocating all the way, or we don't want to apply
+     the relocation to the reloc entry (probably because there isn't
+     any room in the output format to describe addends to relocs).  */
 
   /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
      (OSF version 1.3, compiler version 3.11).  It miscompiles the
@@ -493,11 +481,10 @@ space consuming.  For each target:
 
   relocation >>= (bfd_vma) howto->rightshift;
 
-  /* Shift everything up to where it's going to be used */
-
+  /* Shift everything up to where it's going to be used.  */
   relocation <<= (bfd_vma) howto->bitpos;
 
-  /* Wait for the day when all have the mask in them */
+  /* Wait for the day when all have the mask in them */
 
   /* What we do:
      i instruction to be left alone
@@ -527,8 +514,7 @@ space consuming.  For each target:
      B B B B B
      or              A A A A A
      -----------------------
-     R R R R R R R R R R        put into bfd_put<size>
-     */
+     R R R R R R R R R R        put into bfd_put<size>.  */
 
 #define DOIT(x) \
   x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
@@ -538,39 +524,39 @@ space consuming.  For each target:
     {
     case 0:
       {
-       char x = get_data (location, 1);
+       bfd_vma x = get_data (location, 1);
        DOIT (x);
-       overflow = put_data ((bfd_vma) x, location, 1);
+       put_data ((bfd_vma) x, location, 1);
       }
       break;
 
     case 1:
       if (relocation)
        {
-         short x = get_data (location, 2);
+         bfd_vma x = get_data (location, 2);
          DOIT (x);
-         overflow = put_data ((bfd_vma) x, location, 2);
+         put_data ((bfd_vma) x, location, 2);
        }
       break;
     case 2:
       if (relocation)
        {
-         long x = get_data (location, 4);
+         bfd_vma x = get_data (location, 4);
          DOIT (x);
-         overflow = put_data ((bfd_vma) x, location, 4);
+         put_data ((bfd_vma) x, location, 4);
        }
       break;
     case -2:
       {
-       long x = get_data (location, 4);
+       bfd_vma x = get_data (location, 4);
        relocation = -relocation;
        DOIT(x);
-       overflow = put_data ((bfd_vma) x, location, 4);
+       put_data ((bfd_vma) x, location, 4);
       }
       break;
 
     case 3:
-      /* Do nothing */
+      /* Do nothing */
       break;
 
     case 4:
@@ -579,7 +565,7 @@ space consuming.  For each target:
        {
          bfd_vma x = get_data (location, 8);
          DOIT (x);
-         overflow = put_data (x, location, 8);
+         put_data (x, location, 8);
        }
 #else
       abort ();
@@ -604,7 +590,7 @@ _bfd_do_ns32k_reloc_contents (howto, input_bfd, relocation, location,
      bfd_vma relocation;
      bfd_byte *location;
      bfd_vma (*get_data) PARAMS ((bfd_byte *, int));
-     int (*put_data) PARAMS ((bfd_vma, bfd_byte *, int));
+     void (*put_data) PARAMS ((bfd_vma, bfd_byte *, int));
 {
   int size;
   bfd_vma x;
index 818ae0b..a97a9ae 100644 (file)
@@ -1,22 +1,22 @@
 /* Header file for ns32k routines.
-   Copyright 1996, 2001 Free Software Foundation, Inc.
+   Copyright 1996, 2001, 2002 Free Software Foundation, Inc.
    Written by Cygnus Support.
 
-This file is part of BFD, the Binary File Descriptor library.
+   This file is part of BFD, the Binary File Descriptor library.
 
-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
-(at your option) any later version.
+   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
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-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.  */
+   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.  */
 
 extern bfd_reloc_status_type _bfd_ns32k_relocate_contents
   PARAMS ((reloc_howto_type *, bfd *, bfd_vma, bfd_byte *));
@@ -24,7 +24,7 @@ extern bfd_reloc_status_type _bfd_ns32k_relocate_contents
 extern bfd_reloc_status_type _bfd_do_ns32k_reloc_contents
   PARAMS ((reloc_howto_type *, bfd *, bfd_vma, bfd_byte *,
           bfd_vma (*) (bfd_byte *, int),
-          int (*) (bfd_vma, bfd_byte *, int)));
+          void (*) (bfd_vma, bfd_byte *, int)));
 
 extern bfd_reloc_status_type _bfd_ns32k_final_link_relocate
   PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *, bfd_vma,
@@ -32,8 +32,8 @@ extern bfd_reloc_status_type _bfd_ns32k_final_link_relocate
 
 extern bfd_vma _bfd_ns32k_get_displacement PARAMS ((bfd_byte *, int));
 extern bfd_vma _bfd_ns32k_get_immediate PARAMS ((bfd_byte *, int));
-extern int _bfd_ns32k_put_displacement PARAMS ((bfd_vma, bfd_byte *, int));
-extern int _bfd_ns32k_put_immediate PARAMS ((bfd_vma, bfd_byte *, int));
+extern void _bfd_ns32k_put_displacement PARAMS ((bfd_vma, bfd_byte *, int));
+extern void _bfd_ns32k_put_immediate PARAMS ((bfd_vma, bfd_byte *, int));
 
 extern bfd_reloc_status_type _bfd_ns32k_reloc_disp
   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
index 6595dff..3586257 100644 (file)
@@ -1,3 +1,31 @@
+2002-07-31  Ian Dall  <ian@sibyl.beware.dropbear.id.au>
+
+       * config/tc-ns32k.h (md_pcrel_adjust): Supply prototype.
+       * config/tc-ns32k.c (convert_iif, md_parse_option, md_show_usage):
+       Allow default displacement size to be an option "--disp-size-default".
+       (md_number_to_disp): Make error messages include value. Use %d to
+       print integers, not %s.
+       (fix_new_ns32k): Conditionally set fx_no_overflow so we don't
+       get duplicate messages sometimes.
+       (convert_iif): Grow frag to max possible instruction size. Avoid
+       creating unnecessary fixes.
+       (md_number_to_field) Add prototype.
+       (encode_operand, parse, convert_iif, md_fix_pcrel_adjust): Add
+       prototypes and make static.
+       (struct addr_mode): Make mode and scaled_mode explicitly signed.
+       (evaluate_expr): Use resultP argument instead of exprP global.
+       (get_addr_mode): Quiten compiler warnings.
+       (encode_operand): eliminate unused variables. Quiten compiler
+       warnings. Eliminate nul character in format strings.
+       (parse): argc is unsigned.
+       (reloc): Type cast index to quieten compiler.
+       (md_pcrel_adjust, md_apply_fix3): Remove unused variable.
+       (md_convert_frag): Note unused parameters. Remove unused
+       variables.
+       (md_create_long_jump, md_create_short_jump,
+       md_undefined_symbol_name, md_section_align, tc_gen_reloc): Note
+       unused parameters.
+       
 2002-07-31  Nick Clifton  <nickc@redhat.com>
 
        * NEWS: Retroactively add entry for Lars Brinkhoff's contribution
index 4ed9ea0..bf28f04 100644 (file)
 const char comment_chars[] = "#";
 const char line_comment_chars[] = LINE_COMMENT_CHARS;
 const char line_separator_chars[] = ";";
+static int default_disp_size = 4; /* Displacement size for external refs.  */
 
 #if !defined(ABSOLUTE_PREFIX) && !defined(IMMEDIATE_PREFIX)
-#define ABSOLUTE_PREFIX '@'    /* One or the other MUST be defined */
+#define ABSOLUTE_PREFIX '@'    /* One or the other MUST be defined */
 #endif
 
 struct addr_mode
   {
-    char mode;                 /* addressing mode of operand (0-31) */
-    char scaled_mode;          /* mode combined with scaled mode */
-    char scaled_reg;           /* register used in scaled+1 (1-8) */
-    char float_flag;           /* set if R0..R7 was F0..F7 ie a
-                                  floating-point-register */
-    char am_size;              /* estimated max size of general addr-mode
-                                  parts */
-    char im_disp;              /* if im_disp==1 we have a displacement */
-    char pcrel;                        /* 1 if pcrel, this is really redundant info */
-    char disp_suffix[2];       /* length of displacement(s), 0=undefined */
-    char *disp[2];             /* pointer(s) at displacement(s)
-                                  or immediates(s)     (ascii) */
-    char index_byte;           /* index byte */
+    signed char mode;          /* Addressing mode of operand (0-31).  */
+    signed char scaled_mode;   /* Mode combined with scaled mode.  */
+    char scaled_reg;           /* Register used in scaled+1 (1-8).  */
+    char float_flag;           /* Set if R0..R7 was F0..F7 ie a
+                                  floating-point-register */
+    char am_size;              /* Estimated max size of general addr-mode
+                                  parts */
+    char im_disp;              /* If im_disp==1 we have a displacement.  */
+    char pcrel;                        /* 1 if pcrel, this is really redundant info */
+    char disp_suffix[2];       /* Length of displacement(s), 0=undefined.  */
+    char *disp[2];             /* Pointer(s) at displacement(s)
+                                  or immediates(s)     (ascii) */
+    char index_byte;           /* Index byte.  */
   };
 typedef struct addr_mode addr_modeS;
 
@@ -96,11 +97,11 @@ const char FLT_CHARS[] = "fd";      /* We don't want to support lowercase,
                                    do we?  */
 
 /* UPPERCASE denotes live names when an instruction is built, IIF is
* used as an intermediate form to store the actual parts of the
* instruction. A ns32k machine instruction can be divided into a
* couple of sub PARTs. When an instruction is assembled the
* appropriate PART get an assignment. When an IIF has been completed
* it is converted to a FRAGment as specified in AS.H.  */
  used as an intermediate form to store the actual parts of the
  instruction. A ns32k machine instruction can be divided into a
  couple of sub PARTs. When an instruction is assembled the
  appropriate PART get an assignment. When an IIF has been completed
  it is converted to a FRAGment as specified in AS.H.  */
 
 /* Internal structs.  */
 struct ns32k_option
@@ -112,21 +113,20 @@ struct ns32k_option
 
 typedef struct
   {
-    int type;                  /* how to interpret object */
-    int size;                  /* Estimated max size of object */
-    unsigned long object;      /* binary data */
-    int object_adjust;         /* number added to object */
-    int pcrel;                 /* True if object is pcrel */
-    int pcrel_adjust;          /* length in bytes from the
-                                          instruction start to the
-                                          displacement */
-    int im_disp;               /* True if the object is a displacement */
-    relax_substateT relax_substate;    /* Initial relaxsubstate */
-    bit_fixS *bit_fixP;                /* Pointer at bit_fix struct */
+    int type;                  /* How to interpret object.  */
+    int size;                  /* Estimated max size of object.  */
+    unsigned long object;      /* Binary data.  */
+    int object_adjust;         /* Number added to object.  */
+    int pcrel;                 /* True if object is pcrel.  */
+    int pcrel_adjust;          /* Length in bytes from the instruction
+                                  start to the displacement.  */
+    int im_disp;               /* True if the object is a displacement.  */
+    relax_substateT relax_substate;    /* Initial relaxsubstate.  */
+    bit_fixS *bit_fixP;                /* Pointer at bit_fix struct.  */
     int addr_mode;             /* What addrmode do we associate with this
-                                  iif-entry */
-    char bsr;                  /* Sequent hack */
-  } iif_entryT;                        /* Internal Instruction Format */
+                                  iif-entry */
+    char bsr;                  /* Sequent hack */
+  } iif_entryT;                        /* Internal Instruction Format */
 
 struct int_ins_form
   {
@@ -184,7 +184,7 @@ char *input_line_pointer;
    With this representation we simplify the assembly and separates the
    machine dependent/independent parts in a more clean way (said OE).  */
 \f
-struct ns32k_option opt1[] =           /* restore, exit */
+struct ns32k_option opt1[] =           /* restore, exit */
 {
   {"r0", 0x80, 0xff},
   {"r1", 0x40, 0xff},
@@ -196,7 +196,7 @@ struct ns32k_option opt1[] =                /* restore, exit */
   {"r7", 0x01, 0xff},
   {0, 0x00, 0xff}
 };
-struct ns32k_option opt2[] =           /* save, enter */
+struct ns32k_option opt2[] =           /* save, enter */
 {
   {"r0", 0x01, 0xff},
   {"r1", 0x02, 0xff},
@@ -208,7 +208,7 @@ struct ns32k_option opt2[] =                /* save, enter */
   {"r7", 0x80, 0xff},
   {0, 0x00, 0xff}
 };
-struct ns32k_option opt3[] =           /* setcfg */
+struct ns32k_option opt3[] =           /* setcfg */
 {
   {"c", 0x8, 0xff},
   {"m", 0x4, 0xff},
@@ -216,21 +216,21 @@ struct ns32k_option opt3[] =              /* setcfg */
   {"i", 0x1, 0xff},
   {0, 0x0, 0xff}
 };
-struct ns32k_option opt4[] =           /* cinv */
+struct ns32k_option opt4[] =           /* cinv */
 {
   {"a", 0x4, 0xff},
   {"i", 0x2, 0xff},
   {"d", 0x1, 0xff},
   {0, 0x0, 0xff}
 };
-struct ns32k_option opt5[] =           /* string inst */
+struct ns32k_option opt5[] =           /* String inst.  */
 {
   {"b", 0x2, 0xff},
   {"u", 0xc, 0xff},
   {"w", 0x4, 0xff},
   {0, 0x0, 0xff}
 };
-struct ns32k_option opt6[] =           /* plain reg ext,cvtp etc */
+struct ns32k_option opt6[] =           /* Plain reg ext,cvtp etc.  */
 {
   {"r0", 0x00, 0xff},
   {"r1", 0x01, 0xff},
@@ -247,7 +247,7 @@ struct ns32k_option opt6[] =                /* plain reg ext,cvtp etc */
 #define NS32532
 #endif
 
-struct ns32k_option cpureg_532[] =     /* lpr spr */
+struct ns32k_option cpureg_532[] =     /* lpr spr */
 {
   {"us", 0x0, 0xff},
   {"dcr", 0x1, 0xff},
@@ -264,7 +264,7 @@ struct ns32k_option cpureg_532[] =  /* lpr spr */
   {"mod", 0xf, 0xff},
   {0, 0x00, 0xff}
 };
-struct ns32k_option mmureg_532[] =     /* lmr smr */
+struct ns32k_option mmureg_532[] =     /* lmr smr */
 {
   {"mcr", 0x9, 0xff},
   {"msr", 0xa, 0xff},
@@ -276,7 +276,7 @@ struct ns32k_option mmureg_532[] =  /* lmr smr */
   {0, 0x0, 0xff}
 };
 
-struct ns32k_option cpureg_032[] =     /* lpr spr */
+struct ns32k_option cpureg_032[] =     /* lpr spr */
 {
   {"upsr", 0x0, 0xff},
   {"fp", 0x8, 0xff},
@@ -287,7 +287,7 @@ struct ns32k_option cpureg_032[] =  /* lpr spr */
   {"mod", 0xf, 0xff},
   {0, 0x0, 0xff}
 };
-struct ns32k_option mmureg_032[] =     /* lmr smr */
+struct ns32k_option mmureg_032[] =     /* lmr smr */
 {
   {"bpr0", 0x0, 0xff},
   {"bpr1", 0x1, 0xff},
@@ -367,9 +367,10 @@ char disp_test[] =
 char disp_size[] =
 {4, 1, 2, 0, 4};
 \f
-static void evaluate_expr PARAMS ((expressionS * resultP, char *ptr));
-static void md_number_to_disp PARAMS ((char *buf, long val, int n));
-static void md_number_to_imm PARAMS ((char *buf, long val, int n));
+static void evaluate_expr PARAMS ((expressionS * resultP, char *));
+static void md_number_to_disp PARAMS ((char *, long, int));
+static void md_number_to_imm PARAMS ((char *, long, int));
+static void md_number_to_field PARAMS ((char *, long, bit_fixS *));
 
 /* Parse a general operand into an addressingmode struct
 
@@ -379,25 +380,27 @@ static void md_number_to_imm PARAMS ((char *buf, long val, int n));
 
    Out: data in addr_mode struct.  */
 
-int
+static int addr_mode PARAMS ((char *, addr_modeS *, int));
+
+static int
 addr_mode (operand, addr_modeP, recursive_level)
      char *operand;
-     register addr_modeS *addr_modeP;
+     addr_modeS *addr_modeP;
      int recursive_level;
 {
-  register char *str;
-  register int i;
-  register int strl;
-  register int mode;
+  char *str;
+  int i;
+  int strl;
+  int mode;
   int j;
 
-  mode = DEFAULT;              /* default */
-  addr_modeP->scaled_mode = 0; /* why not */
-  addr_modeP->scaled_reg = 0;  /* if 0, not scaled index */
+  mode = DEFAULT;              /* Default.  */
+  addr_modeP->scaled_mode = 0; /* Why not.  */
+  addr_modeP->scaled_reg = 0;  /* If 0, not scaled index.  */
   addr_modeP->float_flag = 0;
   addr_modeP->am_size = 0;
   addr_modeP->im_disp = 0;
-  addr_modeP->pcrel = 0;       /* not set in this function */
+  addr_modeP->pcrel = 0;       /* Not set in this function.  */
   addr_modeP->disp_suffix[0] = 0;
   addr_modeP->disp_suffix[1] = 0;
   addr_modeP->disp[0] = NULL;
@@ -443,7 +446,7 @@ addr_mode (operand, addr_modeP, recursive_level)
                  return -1;
                }
            default:
-             as_warn (_("Invalid syntax in PC-relative addressing mode"));
+             as_bad (_("Invalid syntax in PC-relative addressing mode"));
              return 0;
            }
        }
@@ -457,7 +460,7 @@ addr_mode (operand, addr_modeP, recursive_level)
              i = 0;
              j = 2;
              do
-               {                       /* disp[0]'s termination point */
+               {                       /* disp[0]'s termination point */
                  j += 1;
                  if (str[j] == '(')
                    i++;
@@ -467,7 +470,7 @@ addr_mode (operand, addr_modeP, recursive_level)
              while (j < strl && i != 0);
              if (i != 0 || !(str[j + 1] == '-' || str[j + 1] == '+'))
                {
-                 as_warn (_("Invalid syntax in External addressing mode"));
+                 as_bad (_("Invalid syntax in External addressing mode"));
                  return (0);
                }
              str[j] = '\000';          /* null terminate disp[0] */
@@ -530,7 +533,8 @@ addr_mode (operand, addr_modeP, recursive_level)
                mode = 18;
 
              if (mode != DEFAULT)
-               {                       /* Memory relative.  */
+               {
+                 /* Memory relative.  */
                  addr_modeP->mode = mode;
                  j = strl - 5;         /* Temp for end of disp[0].  */
                  i = 0;
@@ -547,7 +551,7 @@ addr_mode (operand, addr_modeP, recursive_level)
 
                  if (i != 0)
                    {
-                     as_warn (_("Invalid syntax in Memory Relative addressing mode"));
+                     as_bad (_("Invalid syntax in Memory Relative addressing mode"));
                      return (0);
                    }
 
@@ -614,28 +618,28 @@ addr_mode (operand, addr_modeP, recursive_level)
              mode = 31;
              break;
            default:
-             as_warn (_("Invalid scaled-indexed mode, use (b,w,d,q)"));
+             as_bad (_("Invalid scaled-indexed mode, use (b,w,d,q)"));
 
              if (str[strl - 3] != ':' || str[strl - 6] != '['
                  || str[strl - 5] == 'r' || str[strl - 4] < '0'
                  || str[strl - 4] > '7')
-               as_warn (_("Syntax in scaled-indexed mode, use [Rn:m] where n=[0..7] m={b,w,d,q}"));
+               as_bad (_("Syntax in scaled-indexed mode, use [Rn:m] where n=[0..7] m={b,w,d,q}"));
            } /* Scaled index.  */
 
          if (recursive_level > 0)
            {
-             as_warn (_("Scaled-indexed addressing mode combined with scaled-index"));
+             as_bad (_("Scaled-indexed addressing mode combined with scaled-index"));
              return 0;
            }
 
-         addr_modeP->am_size += 1;     /* scaled index byte */
-         j = str[strl - 4] - '0';      /* store temporary */
-         str[strl - 6] = '\000';       /* nullterminate for recursive call */
+         addr_modeP->am_size += 1;     /* scaled index byte */
+         j = str[strl - 4] - '0';      /* store temporary */
+         str[strl - 6] = '\000';       /* nullterminate for recursive call */
          i = addr_mode (str, addr_modeP, 1);
 
          if (!i || addr_modeP->mode == 20)
            {
-             as_warn (_("Invalid or illegal addressing mode combined with scaled-index"));
+             as_bad (_("Invalid or illegal addressing mode combined with scaled-index"));
              return 0;
            }
 
@@ -659,7 +663,8 @@ addr_mode (operand, addr_modeP, recursive_level)
    specifying suffixes and determines size of immediate mode via
    ns32k-opcode.  Also builds index bytes if needed.  */
 
-int
+static int get_addr_mode PARAMS ((char *, addr_modeS *));
+static int
 get_addr_mode (ptr, addr_modeP)
      char *ptr;
      addr_modeS *addr_modeP;
@@ -700,7 +705,7 @@ get_addr_mode (ptr, addr_modeP)
      case.  Think it does so with local labels too, not optimum, pcrel
      is better.  When I have time I will make gas check this and
      select pcrel when possible Actually that is trivial.  */
-  if (tmp = addr_modeP->scaled_reg)
+  if ((tmp = addr_modeP->scaled_reg))
     {                          /* Build indexbyte.  */
       tmp--;                   /* Remember regnumber comes incremented for
                                   flagpurpose.  */
@@ -709,19 +714,21 @@ get_addr_mode (ptr, addr_modeP)
       addr_modeP->am_size += 1;
     }
 
-  if (disp_test[addr_modeP->mode])
+  assert (addr_modeP->mode >= 0); 
+  if (disp_test[(unsigned int) addr_modeP->mode])
     {
-      register char c;
-      register char suffix;
-      register char suffix_sub;
-      register int i;
-      register char *toP;
-      register char *fromP;
+      char c;
+      char suffix;
+      char suffix_sub;
+      int i;
+      char *toP;
+      char *fromP;
 
       /* There was a displacement, probe for length  specifying suffix.  */
       addr_modeP->pcrel = 0;
 
-      if (disp_test[addr_modeP->mode])
+      assert(addr_modeP->mode >= 0);
+      if (disp_test[(unsigned int) addr_modeP->mode])
        {
          /* There is a displacement.  */
          if (addr_modeP->mode == 27 || addr_modeP->scaled_mode == 27)
@@ -734,12 +741,12 @@ get_addr_mode (ptr, addr_modeP)
            {
              suffix_sub = suffix = 0;
 
-             if (toP = addr_modeP->disp[i])
+             if ((toP = addr_modeP->disp[i]))
                {
                  /* Suffix of expression, the largest size rules.  */
                  fromP = toP;
 
-                 while (c = *fromP++)
+                 while ((c = *fromP++))
                    {
                      *toP++ = c;
                      if (c == ':')
@@ -794,14 +801,15 @@ get_addr_mode (ptr, addr_modeP)
 
 /* Read an optionlist.  */
 
-void
+static void optlist PARAMS ((char *, struct ns32k_option *, unsigned long *));
+static void
 optlist (str, optionP, default_map)
      char *str;                        /* The string to extract options from.  */
      struct ns32k_option *optionP;     /* How to search the string.  */
      unsigned long *default_map;       /* Default pattern and output.  */
 {
-  register int i, j, k, strlen1, strlen2;
-  register char *patternP, *strP;
+  int i, j, k, strlen1, strlen2;
+  char *patternP, *strP;
 
   strlen1 = strlen (str);
 
@@ -837,13 +845,15 @@ optlist (str, optionP, default_map)
    the instructions lmr, smr, lpr, spr return true if str is found in
    list.  */
 
-int
+static int list_search PARAMS ((char *, struct ns32k_option *, unsigned long *));
+
+static int
 list_search (str, optionP, default_map)
      char *str;                                /* The string to match.  */
      struct ns32k_option *optionP;     /* List to search.  */
      unsigned long *default_map;       /* Default pattern and output.  */
 {
-  register int i;
+  int i;
 
   for (i = 0; optionP[i].pattern != 0; i++)
     {
@@ -857,7 +867,7 @@ list_search (str, optionP, default_map)
        }
     }
 
-  as_warn (_("No such entry in list. (cpu/mmu register)"));
+  as_bad (_("No such entry in list. (cpu/mmu register)"));
   return 0;
 }
 
@@ -866,11 +876,11 @@ evaluate_expr (resultP, ptr)
      expressionS *resultP;
      char *ptr;
 {
-  register char *tmp_line;
+  char *tmp_line;
 
   tmp_line = input_line_pointer;
   input_line_pointer = ptr;
-  expression (&exprP);
+  expression (resultP);
   input_line_pointer = tmp_line;
 }
 \f
@@ -880,18 +890,20 @@ evaluate_expr (resultP, ptr)
    opcode.
    Be carefull not to put to objects in the same iif-slot.  */
 
-void
+static void encode_operand PARAMS ((int argc, char **argv, char *operandsP, char *, char, char));
+static void
 encode_operand (argc, argv, operandsP, suffixP, im_size, opcode_bit_ptr)
      int argc;
      char **argv;
      char *operandsP;
      char *suffixP;
-     char im_size;
+     char im_size ATTRIBUTE_UNUSED;
      char opcode_bit_ptr;
 {
-  register int i, j;
+  int i, j;
   char d;
-  int pcrel, tmp, b, loop, pcrel_adjust;
+  int pcrel, b, loop, pcrel_adjust;
+  unsigned long tmp;
 
   for (loop = 0; loop < argc; loop++)
     {
@@ -906,18 +918,18 @@ encode_operand (argc, argv, operandsP, suffixP, im_size, opcode_bit_ptr)
 
       switch ((d = operandsP[(loop << 1) + 1]))
        {
-       case 'f':               /* operand of sfsr turns out to be a nasty
-                                  specialcase */
+       case 'f':               /* Operand of sfsr turns out to be a nasty
+                                  specialcase */
          opcode_bit_ptr -= 5;
-       case 'Z':               /* float not immediate */
-       case 'F':               /* 32 bit float general form */
-       case 'L':               /* 64 bit float */
-       case 'I':               /* integer not immediate */
-       case 'B':               /* byte  */
-       case 'W':               /* word  */
-       case 'D':               /* double-word  */
-       case 'A':               /* double-word  gen-address-form ie no regs
-                                  allowed */
+       case 'Z':               /* Float not immediate.  */
+       case 'F':               /* 32 bit float general form */
+       case 'L':               /* 64 bit float */
+       case 'I':               /* Integer not immediate.  */
+       case 'B':               /* Byte  */
+       case 'W':               /* Word  */
+       case 'D':               /* Double-word.  */
+       case 'A':               /* Double-word  gen-address-form ie no regs
+                                  allowed */
          get_addr_mode (argv[i], &addr_modeP);
 
          if ((addr_modeP.mode == 20) &&
@@ -961,23 +973,23 @@ encode_operand (argc, argv, operandsP, suffixP, im_size, opcode_bit_ptr)
            }
          break;
 
-       case 'b':               /* multiple instruction disp */
-         freeptr++;            /* OVE:this is an useful hack */
-         sprintf (freeptr, "((%s-1)*%d)\000", argv[i], desc->im_size);
+       case 'b':               /* Multiple instruction disp.  */
+         freeptr++;            /* OVE:this is an useful hack */
+         sprintf (freeptr, "((%s-1)*%d)", argv[i], desc->im_size);
          argv[i] = freeptr;
-         pcrel -= 1;           /* make pcrel 0 inspite of what case 'p':
-                                  wants */
+         pcrel -= 1;           /* Make pcrel 0 inspite of what case 'p':
+                                  wants */
          /* fall thru */
-       case 'p':               /* displacement - pc relative addressing */
+       case 'p':               /* Displacement - pc relative addressing.  */
          pcrel += 1;
          /* fall thru */
-       case 'd':               /* displacement */
+       case 'd':               /* Displacement.  */
          iif.instr_size += suffixP[i] ? suffixP[i] : 4;
          IIF (12, 2, suffixP[i], (unsigned long) argv[i], 0,
               pcrel, pcrel_adjust, 1, IND (BRANCH, BYTE), NULL, -1, 0);
          break;
-       case 'H':               /* sequent-hack: the linker wants a bit set
-                                  when bsr */
+       case 'H':               /* Sequent-hack: the linker wants a bit set
+                                  when bsr */
          pcrel = 1;
          iif.instr_size += suffixP[i] ? suffixP[i] : 4;
          IIF (12, 2, suffixP[i], (unsigned long) argv[i], 0,
@@ -988,68 +1000,68 @@ encode_operand (argc, argv, operandsP, suffixP, im_size, opcode_bit_ptr)
          IIF (11, 2, 42, (unsigned long) argv[i], 0, 0, 0, 0, 0,
               bit_fix_new (4, opcode_bit_ptr, -8, 7, 0, 1, 0), -1, 0);
          break;
-       case 'r':               /* register number (3 bits) */
+       case 'r':               /* Register number (3 bits).  */
          list_search (argv[i], opt6, &tmp);
          opcode_bit_ptr -= 3;
          iif.iifP[1].object |= tmp << opcode_bit_ptr;
          break;
-       case 'O':               /* setcfg instruction optionslist */
+       case 'O':               /* Setcfg instruction optionslist.  */
          optlist (argv[i], opt3, &tmp);
          opcode_bit_ptr -= 4;
          iif.iifP[1].object |= tmp << 15;
          break;
-       case 'C':               /* cinv instruction optionslist */
+       case 'C':               /* Cinv instruction optionslist.  */
          optlist (argv[i], opt4, &tmp);
          opcode_bit_ptr -= 4;
-         iif.iifP[1].object |= tmp << 15; /* insert the regtype in opcode */
+         iif.iifP[1].object |= tmp << 15; /* Insert the regtype in opcode.  */
          break;
-       case 'S':               /* stringinstruction optionslist */
+       case 'S':               /* String instruction options list.  */
          optlist (argv[i], opt5, &tmp);
          opcode_bit_ptr -= 4;
          iif.iifP[1].object |= tmp << 15;
          break;
        case 'u':
-       case 'U':               /* registerlist */
+       case 'U':               /* Register list.  */
          IIF (10, 1, 1, 0, 0, 0, 0, 0, 0, NULL, -1, 0);
          switch (operandsP[(i << 1) + 1])
            {
-           case 'u':           /* restore, exit */
+           case 'u':           /* Restore, exit.  */
              optlist (argv[i], opt1, &iif.iifP[10].object);
              break;
-           case 'U':           /* save,enter */
+           case 'U':           /* Save, enter.  */
              optlist (argv[i], opt2, &iif.iifP[10].object);
              break;
            }
          iif.instr_size += 1;
          break;
-       case 'M':               /* mmu register */
+       case 'M':               /* MMU register.  */
          list_search (argv[i], mmureg, &tmp);
          opcode_bit_ptr -= 4;
          iif.iifP[1].object |= tmp << opcode_bit_ptr;
          break;
-       case 'P':               /* cpu register  */
+       case 'P':               /* CPU register.  */
          list_search (argv[i], cpureg, &tmp);
          opcode_bit_ptr -= 4;
          iif.iifP[1].object |= tmp << opcode_bit_ptr;
          break;
-       case 'g':               /* inss exts */
-         iif.instr_size += 1;  /* 1 byte is allocated after the opcode */
+       case 'g':               /* Inss exts.  */
+         iif.instr_size += 1;  /* 1 byte is allocated after the opcode */
          IIF (10, 2, 1,
-              (unsigned long) argv[i], /* i always 2 here */
+              (unsigned long) argv[i], /* i always 2 here */
               0, 0, 0, 0, 0,
-              bit_fix_new (3, 5, 0, 7, 0, 0, 0), /* a bit_fix is targeted to
-                                                    the byte */
+              bit_fix_new (3, 5, 0, 7, 0, 0, 0), /* A bit_fix is targeted to
+                                                    the byte */
               -1, 0);
          break;
        case 'G':
          IIF (11, 2, 42,
-              (unsigned long) argv[i], /* i always 3 here */
+              (unsigned long) argv[i], /* i always 3 here */
               0, 0, 0, 0, 0,
               bit_fix_new (5, 0, 1, 32, -1, 0, -1), -1, 0);
          break;
        case 'i':
          iif.instr_size += 1;
-         b = 2 + i;            /* put the extension byte after opcode */
+         b = 2 + i;            /* Put the extension byte after opcode.  */
          IIF (b, 2, 1, 0, 0, 0, 0, 0, 0, 0, -1, 0);
          break;
        default:
@@ -1062,17 +1074,19 @@ encode_operand (argc, argv, operandsP, suffixP, im_size, opcode_bit_ptr)
    out: internal structure of instruction
    that has been prepared for direct conversion to fragment(s) and
    fixes in a systematical fashion
-   Return-value = recursive_level.    */
+   Return-value = recursive_level.  */
 /* Build iif of one assembly text line.  */
 
-int
+static int parse PARAMS ((char *, int));
+static int
 parse (line, recursive_level)
      char *line;
      int recursive_level;
 {
-  register char *lineptr, c, suffix_separator;
-  register int i;
-  int argc, arg_type;
+  char *lineptr, c, suffix_separator;
+  int i;
+  unsigned int argc;
+  int arg_type;
   char sqr, sep;
   char suffix[MAX_ARGS], *argv[MAX_ARGS];      /* No more than 4 operands.  */
 
@@ -1128,7 +1142,7 @@ parse (line, recursive_level)
                      break;
                    }
 
-                 suffix[argc] = 0; /* 0 when no ':' is encountered */
+                 suffix[argc] = 0; /* 0 when no ':' is encountered */
                  argv[argc] = freeptr;
                  *freeptr = '\0';
 
@@ -1257,7 +1271,8 @@ parse (line, recursive_level)
    objects not part of an instruction, the pointer to the opcode frag
    is always zero.  */
 
-void
+static void convert_iif PARAMS ((void));
+static void
 convert_iif ()
 {
   int i;
@@ -1270,8 +1285,8 @@ convert_iif ()
   int k;
   char type;
   char size = 0;
-  int size_so_far;
 
+  frag_grow (iif.instr_size);  /* This is important.  */
   memP = frag_more (0);
   inst_opcode = memP;
   inst_offset = (memP - frag_now->fr_literal);
@@ -1279,7 +1294,7 @@ convert_iif ()
 
   for (i = 0; i < IIF_ENTRIES; i++)
     {
-      if (type = iif.iifP[i].type)
+      if ((type = iif.iifP[i].type))
        {
          /* The object exist, so handle it.  */
          switch (size = iif.iifP[i].size)
@@ -1292,7 +1307,7 @@ convert_iif ()
                iif.iifP[i].bit_fixP->fx_bit_base = (long) inst_opcode;
              /* Fall through.  */
 
-           case 8:             /* bignum or doublefloat */
+           case 8:             /* bignum or doublefloat */
            case 1:
            case 2:
            case 3:
@@ -1304,7 +1319,11 @@ convert_iif ()
              switch (type)
                {
                case 1: /* The object is pure binary.  */
-                 if (j || iif.iifP[i].pcrel)
+                 if (j)
+                   {
+                     md_number_to_field(memP, exprP.X_add_number, j);
+                   }
+                 else if (iif.iifP[i].pcrel)
                    {
                      fix_new_ns32k (frag_now,
                                     (long) (memP - frag_now->fr_literal),
@@ -1313,8 +1332,8 @@ convert_iif ()
                                     iif.iifP[i].object,
                                     iif.iifP[i].pcrel,
                                     iif.iifP[i].im_disp,
-                                    j,
-                                    iif.iifP[i].bsr,   /* sequent hack */
+                                    0,
+                                    iif.iifP[i].bsr,   /* Sequent hack.  */
                                     inst_frag, inst_offset);
                    }
                  else
@@ -1346,17 +1365,15 @@ convert_iif ()
                          /* We have a bignum ie a quad. This can only
                              happens in a long suffixed instruction.  */
                          if (k * 2 > size)
-                           as_warn (_("Bignum too big for long"));
+                           as_bad (_("Bignum too big for long"));
 
                          if (k == 3)
                            memP += 2;
 
                          for (l = 0; k > 0; k--, l += 2)
-                           {
-                             md_number_to_chars (memP + l,
-                                                 generic_bignum[l >> 1],
-                                                 sizeof (LITTLENUM_TYPE));
-                           }
+                           md_number_to_chars (memP + l,
+                                               generic_bignum[l >> 1],
+                                               sizeof (LITTLENUM_TYPE));
                        }
                      else
                        {
@@ -1393,8 +1410,7 @@ convert_iif ()
                        }
                      break;
                    }
-                 if (j ||
-                     exprP.X_add_symbol ||
+                 if (exprP.X_add_symbol ||
                      exprP.X_op_symbol ||
                      iif.iifP[i].pcrel)
                    {
@@ -1412,6 +1428,10 @@ convert_iif ()
                                         iif.iifP[i].bsr,
                                         inst_frag, inst_offset);
                    }
+                 else if (j)
+                   {
+                     md_number_to_field(memP, exprP.X_add_number, j);
+                   }
                  else
                    {
                      /* Good, just put them bytes out.  */
@@ -1445,9 +1465,8 @@ convert_iif ()
                if ((exprP.X_add_symbol || exprP.X_op_symbol) &&
                    !iif.iifP[i].pcrel)
                  {
-                   /* Size is unknown until link time so have to
-                       allow 4 bytes.  */
-                   size = 4;
+                   /* Size is unknown until link time so have to default.  */
+                   size = default_disp_size; /* Normally 4 bytes.  */
                    memP = frag_more (size);
                    fix_new_ns32k_exp (frag_now,
                                       (long) (memP - frag_now->fr_literal),
@@ -1458,7 +1477,7 @@ convert_iif ()
                                       (bit_fixS *) 0, 0,
                                       inst_frag,
                                       inst_offset);
-                   break;              /* exit this absolute hack */
+                   break;              /* Exit this absolute hack.  */
                  }
 
                if (exprP.X_add_symbol || exprP.X_op_symbol)
@@ -1515,7 +1534,7 @@ convert_iif ()
                              }
                            else
                              {
-                               as_warn (_("Displacement to large for :d"));
+                               as_bad (_("Displacement to large for :d"));
                                size = 4;
                              }
                          }
@@ -1584,7 +1603,7 @@ reloc (int size, int pcrel, int type)
 
   index = length + 3 * pcrel + 6 * type;
 
-  if (index >= 0 && index < sizeof (relocs) / sizeof (relocs[0]))
+  if (index >= 0 && (unsigned int) index < sizeof (relocs) / sizeof (relocs[0]))
     return relocs[index];
 
   if (pcrel)
@@ -1711,7 +1730,7 @@ md_number_to_disp (buf, val, n)
     {
     case 1:
       if (val < -64 || val > 63)
-       as_warn (_("Byte displacement out of range.  line number not valid"));
+       as_bad (_("value of %ld out of byte displacement range."), val);
       val &= 0x7f;
 #ifdef SHOW_NUM
       printf ("%x ", val & 0xff);
@@ -1720,7 +1739,7 @@ md_number_to_disp (buf, val, n)
       break;
     case 2:
       if (val < -8192 || val > 8191)
-       as_warn (_("Word displacement out of range.  line number not valid"));
+       as_bad (_("value of %ld out of word displacement range."), val);
       val &= 0x3fff;
       val |= 0x8000;
 #ifdef SHOW_NUM
@@ -1734,7 +1753,7 @@ md_number_to_disp (buf, val, n)
       break;
     case 4:
       if (val < -0x20000000 || val >= 0x20000000)
-       as_warn (_("Double word displacement out of range"));
+       as_bad (_("value of %ld out of double word displacement range."), val);
       val |= 0xc0000000;
 #ifdef SHOW_NUM
       printf ("%x ", val >> 24 & 0xff);
@@ -1754,7 +1773,7 @@ md_number_to_disp (buf, val, n)
       *buf++ = val;
       break;
     default:
-      as_fatal (_("Internal logic error.  line %s, file \"%s\""),
+      as_fatal (_("Internal logic error.  line %d, file \"%s\""),
                __LINE__, __FILE__);
     }
 }
@@ -1802,7 +1821,7 @@ md_number_to_imm (buf, val, n)
       *buf++ = val;
       break;
     default:
-      as_fatal (_("Internal logic error. line %s, file \"%s\""),
+      as_fatal (_("Internal logic error. line %d, file \"%s\""),
                __LINE__, __FILE__);
     }
 }
@@ -1841,18 +1860,19 @@ static unsigned long r_mask[] =
 
 static void
 md_number_to_field (buf, val, field_ptr)
-     register char *buf;
-     register long val;
-     register bit_fixS *field_ptr;
+     char *buf;
+     long val;
+     bit_fixS *field_ptr;
 {
-  register unsigned long object;
-  register unsigned long mask;
-  /* define ENDIAN on a ns32k machine */
+  unsigned long object;
+  unsigned long mask;
+  /* Define ENDIAN on a ns32k machine.  */
 #ifdef ENDIAN
-  register unsigned long *mem_ptr;
+  unsigned long *mem_ptr;
 #else
-  register char *mem_ptr;
+  char *mem_ptr;
 #endif
+
   if (field_ptr->fx_bit_min <= val && val <= field_ptr->fx_bit_max)
     {
 #ifdef ENDIAN
@@ -1875,7 +1895,7 @@ md_number_to_field (buf, val, field_ptr)
 #ifdef ENDIAN
       /* We have a nice ns32k machine with lowbyte at low-physical mem.  */
       object = *mem_ptr;       /* get some bytes */
-#else /* OVE Goof! the machine is a m68k or dito */
+#else /* OVE Goof! the machine is a m68k or dito */
       /* That takes more byte fiddling.  */
       object = 0;
       object |= mem_ptr[3] & 0xff;
@@ -1906,7 +1926,7 @@ md_number_to_field (buf, val, field_ptr)
     }
   else
     {
-      as_warn (_("Bit field out of range"));
+      as_bad (_("Bit field out of range"));
     }
 }
 
@@ -1928,11 +1948,11 @@ md_pcrel_adjust (fragP)
   return fragP->fr_address + fragP->fr_fix - opcode_address;
 }
 
-int
+static int md_fix_pcrel_adjust PARAMS ((fixS *fixP));
+static int
 md_fix_pcrel_adjust (fixP)
      fixS *fixP;
 {
-  fragS *fragP = fixP->fx_frag;
   fragS *opcode_frag;
   addressT opcode_address;
   unsigned int offset;
@@ -1961,13 +1981,13 @@ md_apply_fix3 (fixP, valP, seg)
      segT seg ATTRIBUTE_UNUSED;
 {
   long val = * (long *) valP;
-  fragS *fragP = fixP->fx_frag;
   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
 
   if (fix_bit_fixP (fixP))
-    /* Bitfields to fix, sigh.  */
-    md_number_to_field (buf, val, fix_bit_fixP (fixP));
-
+    {
+      /* Bitfields to fix, sigh.  */
+      md_number_to_field (buf, val, fix_bit_fixP (fixP));
+    }
   else switch (fix_im_disp (fixP))
     {
     case 0:
@@ -1977,7 +1997,7 @@ md_apply_fix3 (fixP, valP, seg)
 
     case 1:
       /* Displacement field.  */
-      /* Calculate offset */
+      /* Calculate offset */
       md_number_to_disp (buf,
                         (fixP->fx_pcrel ? val + md_fix_pcrel_adjust (fixP)
                          : val), fixP->fx_size);
@@ -1993,32 +2013,29 @@ md_apply_fix3 (fixP, valP, seg)
     fixP->fx_done = 1;
 }
 \f
-/* Convert a relaxed displacement to ditto in final output */
+/* Convert a relaxed displacement to ditto in final output */
 
 #ifndef BFD_ASSEMBLER
 void
 md_convert_frag (headers, sec, fragP)
      object_headers *headers;
      segT sec;
-     register fragS *fragP;
+     fragS *fragP;
 #else
 void
 md_convert_frag (abfd, sec, fragP)
-     bfd *abfd;
-     segT sec;
-     register fragS *fragP;
+     bfd *abfd ATTRIBUTE_UNUSED;
+     segT sec ATTRIBUTE_UNUSED;
+     fragS *fragP;
 #endif
 {
   long disp;
   long ext = 0;
-
   /* Address in gas core of the place to store the displacement.  */
-  register char *buffer_address = fragP->fr_fix + fragP->fr_literal;
+  char *buffer_address = fragP->fr_fix + fragP->fr_literal;
   /* Address in object code of the displacement.  */
   int object_address;
 
-  fragS *opcode_frag;
-
   switch (fragP->fr_subtype)
     {
     case IND (BRANCH, BYTE):
@@ -2053,7 +2070,7 @@ md_convert_frag (abfd, sec, fragP)
 
 int
 md_estimate_size_before_relax (fragP, segment)
-     register fragS *fragP;
+     fragS *fragP;
      segT segment;
 {
   if (fragP->fr_subtype == IND (BRANCH, UNDEF))
@@ -2070,7 +2087,7 @@ md_estimate_size_before_relax (fragP, segment)
                         1,
                         1,
                         0,
-                        frag_bsr(fragP), /*sequent hack */
+                        frag_bsr(fragP), /* Sequent hack.  */
                         frag_opcode_frag (fragP),
                         frag_opcode_offset (fragP));
          fragP->fr_fix += 4;
@@ -2101,8 +2118,8 @@ void
 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
      char *ptr;
      addressT from_addr, to_addr;
-     fragS *frag;
-     symbolS *to_symbol;
+     fragS *frag ATTRIBUTE_UNUSED;
+     symbolS *to_symbol ATTRIBUTE_UNUSED;
 {
   valueT offset;
 
@@ -2115,8 +2132,8 @@ void
 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
      char *ptr;
      addressT from_addr, to_addr;
-     fragS *frag;
-     symbolS *to_symbol;
+     fragS *frag ATTRIBUTE_UNUSED;
+     symbolS *to_symbol ATTRIBUTE_UNUSED;
 {
   valueT offset;
 
@@ -2129,6 +2146,8 @@ const char *md_shortopts = "m:";
 
 struct option md_longopts[] =
 {
+#define OPTION_DISP_SIZE (OPTION_MD_BASE)
+  {"disp-size-default", required_argument , NULL, OPTION_DISP_SIZE},
   {NULL, no_argument, NULL, 0}
 };
 
@@ -2154,10 +2173,24 @@ md_parse_option (c, arg)
        }
       else
        {
-         as_bad (_("invalid architecture option -m%s"), arg);
+         as_warn (_("invalid architecture option -m%s, ignored"), arg);
          return 0;
        }
       break;
+    case OPTION_DISP_SIZE:
+      {
+       int size = atoi(arg);
+       switch (size)
+         {
+         case 1: case 2: case 4:
+           default_disp_size = size;
+           break;
+         default:
+           as_warn (_("invalid default displacement size \"%s\". Defaulting to %d."),
+                    arg, default_disp_size);
+         }
+       break;
+      }
 
     default:
       return 0;
@@ -2172,7 +2205,8 @@ md_show_usage (stream)
 {
   fprintf (stream, _("\
 NS32K options:\n\
--m32032 | -m32532      select variant of NS32K architecture\n"));
+-m32032 | -m32532      select variant of NS32K architecture\n\
+--disp-size-default=<1|2|4>\n"));
 }
 \f
 /* Create a bit_fixS in obstack 'notes'.
@@ -2182,15 +2216,15 @@ NS32K options:\n\
 
 bit_fixS *
 bit_fix_new (size, offset, min, max, add, base_type, base_adj)
-     char size;                        /* Length of bitfield           */
-     char offset;              /* Bit offset to bitfield       */
-     long min;                 /* Signextended min for bitfield */
-     long max;                 /* Signextended max for bitfield */
-     long add;                 /* Add mask, used for huffman prefix */
-     long base_type;           /* 0 or 1, if 1 it's exploded to opcode ptr */
+     char size;                        /* Length of bitfield.  */
+     char offset;              /* Bit offset to bitfield.  */
+     long min;                 /* Signextended min for bitfield */
+     long max;                 /* Signextended max for bitfield */
+     long add;                 /* Add mask, used for huffman prefix */
+     long base_type;           /* 0 or 1, if 1 it's exploded to opcode ptr */
      long base_adj;
 {
-  register bit_fixS *bit_fixP;
+  bit_fixS *bit_fixP;
 
   bit_fixP = (bit_fixS *) obstack_alloc (&notes, sizeof (bit_fixS));
 
@@ -2202,7 +2236,7 @@ bit_fix_new (size, offset, min, max, add, base_type, base_adj)
   bit_fixP->fx_bit_min = min;
   bit_fixP->fx_bit_add = add;
 
-  return (bit_fixP);
+  return bit_fixP;
 }
 
 void
@@ -2213,13 +2247,13 @@ fix_new_ns32k (frag, where, size, add_symbol, offset, pcrel,
      int size;                 /* 1, 2  or 4 usually.  */
      symbolS *add_symbol;      /* X_add_symbol.  */
      long offset;              /* X_add_number.  */
-     int pcrel;                        /* TRUE if PC-relative relocation.  */
-     char im_disp;             /* true if the value to write is a
-                                  displacement */
-     bit_fixS *bit_fixP;       /* pointer at struct of bit_fix's, ignored if
-                                  NULL */
-     char bsr;                 /* sequent-linker-hack: 1 when relocobject is
-                                  a bsr */
+     int pcrel;                        /* True if PC-relative relocation.  */
+     char im_disp;             /* True if the value to write is a
+                                  displacement */
+     bit_fixS *bit_fixP;       /* Pointer at struct of bit_fix's, ignored if
+                                  NULL */
+     char bsr;                 /* Sequent-linker-hack: 1 when relocobject is
+                                  a bsr */
      fragS *opcode_frag;
      unsigned int opcode_offset;
 {
@@ -2237,6 +2271,8 @@ fix_new_ns32k (frag, where, size, add_symbol, offset, pcrel,
   fix_im_disp (fixP) = im_disp;
   fix_bsr (fixP) = bsr;
   fix_bit_fixP (fixP) = bit_fixP;
+  /* We have a MD overflow check for displacements.  */
+  fixP->fx_no_overflow = (im_disp != 0);
 }
 
 void
@@ -2246,13 +2282,13 @@ fix_new_ns32k_exp (frag, where, size, exp, pcrel,
      int where;                        /* Where in that frag? */
      int size;                 /* 1, 2  or 4 usually.  */
      expressionS *exp;         /* Expression.  */
-     int pcrel;                        /* TRUE if PC-relative relocation.  */
-     char im_disp;             /* true if the value to write is a
-                                  displacement */
-     bit_fixS *bit_fixP;       /* pointer at struct of bit_fix's, ignored if
-                                  NULL */
-     char bsr;                 /* sequent-linker-hack: 1 when relocobject is
-                                  a bsr */
+     int pcrel;                        /* True if PC-relative relocation.  */
+     char im_disp;             /* True if the value to write is a
+                                  displacement */
+     bit_fixS *bit_fixP;       /* Pointer at struct of bit_fix's, ignored if
+                                  NULL */
+     char bsr;                 /* Sequent-linker-hack: 1 when relocobject is
+                                  a bsr */
      fragS *opcode_frag;
      unsigned int opcode_offset;
 {
@@ -2269,6 +2305,8 @@ fix_new_ns32k_exp (frag, where, size, exp, pcrel,
   fix_im_disp (fixP) = im_disp;
   fix_bsr (fixP) = bsr;
   fix_bit_fixP (fixP) = bit_fixP;
+  /* We have a MD overflow check for displacements.  */
+  fixP->fx_no_overflow = (im_disp != 0);
 }
 
 /* This is TC_CONS_FIX_NEW, called by emit_expr in read.c.  */
@@ -2288,7 +2326,7 @@ cons_fix_new_ns32k (frag, where, size, exp)
 
 symbolS *
 md_undefined_symbol (name)
-     char *name;
+     char *name ATTRIBUTE_UNUSED;
 {
   return 0;
 }
@@ -2297,7 +2335,7 @@ md_undefined_symbol (name)
 
 valueT
 md_section_align (segment, size)
-     segT segment;
+     segT segment ATTRIBUTE_UNUSED;
      valueT size;
 {
   return size;                 /* Byte alignment is fine.  */
@@ -2311,6 +2349,7 @@ md_pcrel_from (fixP)
      fixS *fixP;
 {
   long res;
+
   res = fixP->fx_where + fixP->fx_frag->fr_address;
 #ifdef SEQUENT_COMPATABILITY
   if (frag_bsr (fixP->fx_frag))
@@ -2323,7 +2362,7 @@ md_pcrel_from (fixP)
 
 arelent *
 tc_gen_reloc (section, fixp)
-     asection *section;
+     asection *section ATTRIBUTE_UNUSED;
      fixS *fixp;
 {
   arelent *rel;
index 258afd0..417395d 100644 (file)
@@ -1,5 +1,5 @@
 /* tc-ns32k.h -- Opcode table for National Semi 32k processor
-   Copyright 1987, 1992, 1993, 1994, 1995, 1997, 2000
+   Copyright 1987, 1992, 1993, 1994, 1995, 1997, 2000, 2002
    Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.
@@ -24,6 +24,7 @@
 #define TARGET_BYTES_BIG_ENDIAN        0
 
 #define TC_PCREL_ADJUST(F) md_pcrel_adjust(F)
+extern int md_pcrel_adjust PARAMS((fragS *fragP));
 
 #ifdef BFD_ASSEMBLER
 #define NO_RELOC BFD_RELOC_NONE
 #define ARG_LEN 50
 
 #define TC_CONS_FIX_NEW cons_fix_new_ns32k
-extern void fix_new_ns32k_exp PARAMS((fragS *frag,
-                                  int where,
-                                  int size,
-                                  expressionS *exp,
-                                  int pcrel,
-                                  int im_disp,
-                                  bit_fixS *bit_fixP,  /* really bit_fixS */
-                                  int bsr,
-                                  fragS *opcode_frag,
-                                  unsigned int opcode_offset));
-
-extern void fix_new_ns32k PARAMS ((fragS *frag,
-                                  int where,
-                                  int size,
-                                  symbolS *add_symbol,
-                                  long offset,
-                                  int pcrel,
-                                  int im_disp,
-                                  bit_fixS *bit_fixP,  /* really bit_fixS */
-                                  int bsr,
-                                  fragS *opcode_frag,
-                                  unsigned int opcode_offset));
-
-extern void cons_fix_new_ns32k PARAMS ((fragS *frag,
-                                       int where,
-                                       int size,
-                                       expressionS *exp));
-
-/* the NS32x32 has a non 0 nop instruction which should be used in aligns */
+extern void fix_new_ns32k_exp PARAMS ((fragS *, int, int, expressionS *,
+                                      int, int, bit_fixS *, int, fragS *,
+                                      unsigned int));
+
+extern void fix_new_ns32k PARAMS ((fragS *, int, int, symbolS *, long,
+                                  int, int, bit_fixS *, int, fragS *,
+                                  unsigned int));
+
+extern void cons_fix_new_ns32k PARAMS ((fragS *, int, int, expressionS *));
+
+/* The NS32x32 has a non 0 nop instruction which should be used in aligns.  */
 #define NOP_OPCODE 0xa2
 
 #define md_operand(x)
@@ -99,33 +82,34 @@ extern const struct relax_type md_relax_table[];
 #define TC_GENERIC_RELAX_TABLE md_relax_table
 
 #define TC_FRAG_TYPE                           \
-struct {                                       \
-  fragS *fr_opcode_fragP;                      \
-  unsigned int fr_opcode_offset;               \
-  char fr_bsr;                                 \
-}
+  struct                                       \
+    {                                          \
+      fragS *      fr_opcode_fragP;            \
+      unsigned int fr_opcode_offset;           \
+      char         fr_bsr;                     \
+    }
 
 #define TC_FRAG_INIT(X)                                \
   do                                           \
      {                                         \
        frag_opcode_frag (X) = NULL;            \
        frag_opcode_offset (X) = 0;             \
-       frag_bsr (X) = 0;                               \
+       frag_bsr (X) = 0;                       \
      }                                         \
   while (0)
 
-/* Accessor macros for things which may move around */
+/* Accessor macros for things which may move around */
 #define frag_opcode_frag(X)   (X)->tc_frag_data.fr_opcode_fragP
 #define frag_opcode_offset(X) (X)->tc_frag_data.fr_opcode_offset
 #define frag_bsr(X)           (X)->tc_frag_data.fr_bsr
 
 #define TC_FIX_TYPE                            \
-struct                                         \
-{                                              \
-  fragS *opcode_fragP;                         \
-  unsigned int opcode_offset;                  \
-  unsigned int bsr : 1;                                \
-}
+  struct                                       \
+    {                                          \
+      fragS *      opcode_fragP;               \
+      unsigned int opcode_offset;              \
+      unsigned int bsr : 1;                    \
+    }
 
 /* Accessor macros for things which may move around.
    See comments in write.h.  */