projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
[gdb/symtab] Prefer def over decl (inter-CU case, with context)
[deliverable/binutils-gdb.git] / cpu / m32c.opc
diff --git a/cpu/m32c.opc b/cpu/m32c.opc
index 04baa9c5ebf5f839116b9d3070e712b8bbdcadb1..2796e1c1cffb1bfa3dff4a34baa3947b3621ff4b 100644 (file)
--- a/cpu/m32c.opc
+++ b/cpu/m32c.opc
@@ -1,6 +1,6 @@
 /* m32c opcode support.  -*- C -*-
 
 /* m32c opcode support.  -*- C -*-
 
-   Copyright 2005 Free Software Foundation, Inc.
+   Copyright 2005, 2007, 2009, 2010 Free Software Foundation, Inc.
 
    Contributed by Red Hat Inc; developed under contract from Renesas
 
 
    Contributed by Red Hat Inc; developed under contract from Renesas
 
@@ -8,7 +8,7 @@
 
    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 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,
@@ -18,7 +18,9 @@
 
    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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+   MA 02110-1301, USA.  */
+
 
 /* This file is an addendum to m32c.cpu.  Heavy use of C code isn't
    appropriate in .cpu files, so it resides here.  This especially applies
 
 /* This file is an addendum to m32c.cpu.  Heavy use of C code isn't
    appropriate in .cpu files, so it resides here.  This especially applies
@@ -33,14 +35,13 @@
    <arch>-opc.c additions use: "-- opc.c"
    <arch>-asm.c additions use: "-- asm.c"
    <arch>-dis.c additions use: "-- dis.c"
    <arch>-opc.c additions use: "-- opc.c"
    <arch>-asm.c additions use: "-- asm.c"
    <arch>-dis.c additions use: "-- dis.c"
-   <arch>-ibd.h additions use: "-- ibd.h"
-*/
+   <arch>-ibd.h additions use: "-- ibd.h".  */
 \f
 /* -- opc.h */
 
 /* Needed for RTL's 'ext' and 'trunc' operators.  */
 \f
 /* -- opc.h */
 
 /* Needed for RTL's 'ext' and 'trunc' operators.  */
-#include "cgen-types.h"
-#include "cgen-ops.h"
+#include "cgen/basic-modes.h"
+#include "cgen/basic-ops.h"
 
 /* We can't use the default hash size because many bits are used by
    operands.  */
 
 /* We can't use the default hash size because many bits are used by
    operands.  */
@@ -70,13 +71,17 @@ m32c_asm_hash (const char *mnem)
   if (mnem[0] == 's' && mnem[1] == 'c')
     return 's';
   
   if (mnem[0] == 's' && mnem[1] == 'c')
     return 's';
   
+  /* Don't hash bmCND  */
+  if (mnem[0] == 'b' && mnem[1] == 'm')
+    return 'b';
+  
   for (h = 0; *mnem && *mnem != ' ' && *mnem != ':'; ++mnem)
     h += *mnem;
   return h % CGEN_ASM_HASH_SIZE;
 }
 \f
 /* -- asm.c */
   for (h = 0; *mnem && *mnem != ' ' && *mnem != ':'; ++mnem)
     h += *mnem;
   return h % CGEN_ASM_HASH_SIZE;
 }
 \f
 /* -- asm.c */
-#include <ctype.h>
+#include "safe-ctype.h"
 
 #define MACH_M32C 5            /* Must match md_begin.  */
 
 
 #define MACH_M32C 5            /* Must match md_begin.  */
 
@@ -104,25 +109,40 @@ m32c_cgen_isa_register (const char **strp)
    return 0;
 }
 
    return 0;
 }
 
+#define PARSE_UNSIGNED                                                 \
+  do                                                                   \
+    {                                                                  \
+      /* Don't successfully parse literals beginning with '['.  */     \
+      if (**strp == '[')                                               \
+       return "Invalid literal"; /* Anything -- will not be seen.  */  \
+                                                                       \
+      errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);\
+      if (errmsg)                                                      \
+       return errmsg;                                                  \
+    }                                                                  \
+  while (0)
+
+#define PARSE_SIGNED                                                   \
+  do                                                                   \
+    {                                                                  \
+      /* Don't successfully parse literals beginning with '['.  */     \
+      if (**strp == '[')                                               \
+       return "Invalid literal"; /* Anything -- will not be seen.  */  \
+                                                                       \
+      errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);  \
+      if (errmsg)                                                      \
+       return errmsg;                                                  \
+    }                                                                  \
+  while (0)
+
 static const char *
 parse_unsigned6 (CGEN_CPU_DESC cd, const char **strp,
                 int opindex, unsigned long *valuep)
 {
   const char *errmsg = 0;
   unsigned long value;
 static const char *
 parse_unsigned6 (CGEN_CPU_DESC cd, const char **strp,
                 int opindex, unsigned long *valuep)
 {
   const char *errmsg = 0;
   unsigned long value;
-  long have_zero = 0;
-
-  /* Don't successfully parse literals beginning with '[' */
-  if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
 
 
-  if (strncmp (*strp, "0x0", 3) == 0 
-      || (**strp == '0' && *(*strp + 1) != 'x'))
-    have_zero = 1;
-
-  errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
-  if (errmsg)
-    return errmsg;
+  PARSE_UNSIGNED;
 
   if (value > 0x3f)
     return _("imm:6 immediate is out of range");
 
   if (value > 0x3f)
     return _("imm:6 immediate is out of range");
@@ -136,20 +156,35 @@ parse_unsigned8 (CGEN_CPU_DESC cd, const char **strp,
                 int opindex, unsigned long *valuep)
 {
   const char *errmsg = 0;
                 int opindex, unsigned long *valuep)
 {
   const char *errmsg = 0;
-  unsigned long value;
+  unsigned long value = 0;
   long have_zero = 0;
 
   long have_zero = 0;
 
-  /* Don't successfully parse literals beginning with '[' */
-  if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
+  if (strncasecmp (*strp, "%dsp8(", 6) == 0)
+    {
+      enum cgen_parse_operand_result result_type;
+      bfd_vma val;
+
+      *strp += 6;
+      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_8,
+                                  & result_type, & val);
+      if (**strp != ')')
+       return _("missing `)'");
+      (*strp) ++;
+
+      if (errmsg == NULL
+         && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+       return _("%dsp8() takes a symbolic address, not a number");
+
+      value = val;
+      *valuep = value;
+      return errmsg;
+    }
 
   if (strncmp (*strp, "0x0", 3) == 0 
       || (**strp == '0' && *(*strp + 1) != 'x'))
     have_zero = 1;
 
 
   if (strncmp (*strp, "0x0", 3) == 0 
       || (**strp == '0' && *(*strp + 1) != 'x'))
     have_zero = 1;
 
-  errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
-  if (errmsg)
-    return errmsg;
+  PARSE_UNSIGNED;
 
   if (value > 0xff)
     return _("dsp:8 immediate is out of range");
 
   if (value > 0xff)
     return _("dsp:8 immediate is out of range");
@@ -169,18 +204,12 @@ parse_signed4 (CGEN_CPU_DESC cd, const char **strp,
   const char *errmsg = 0;
   signed long value;
   long have_zero = 0;
   const char *errmsg = 0;
   signed long value;
   long have_zero = 0;
-  
-  /* Don't successfully parse literals beginning with '[' */
-  if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
 
   if (strncmp (*strp, "0x0", 3) == 0 
       || (**strp == '0' && *(*strp + 1) != 'x'))
     have_zero = 1;
 
 
   if (strncmp (*strp, "0x0", 3) == 0 
       || (**strp == '0' && *(*strp + 1) != 'x'))
     have_zero = 1;
 
-  errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
-  if (errmsg)
-    return errmsg;
+  PARSE_SIGNED;
 
   if (value < -8 || value > 7)
     return _("Immediate is out of range -8 to 7");
 
   if (value < -8 || value > 7)
     return _("Immediate is out of range -8 to 7");
@@ -193,20 +222,60 @@ parse_signed4 (CGEN_CPU_DESC cd, const char **strp,
   return 0;
 }
 
   return 0;
 }
 
+static const char *
+parse_signed4n (CGEN_CPU_DESC cd, const char **strp,
+               int opindex, signed long *valuep)
+{
+  const char *errmsg = 0;
+  signed long value;
+  long have_zero = 0;
+
+  if (strncmp (*strp, "0x0", 3) == 0 
+      || (**strp == '0' && *(*strp + 1) != 'x'))
+    have_zero = 1;
+
+  PARSE_SIGNED;
+
+  if (value < -7 || value > 8)
+    return _("Immediate is out of range -7 to 8");
+
+  /* If this field may require a relocation then use larger dsp16.  */
+  if (! have_zero && value == 0)
+    return _("Immediate is out of range -7 to 8");
+
+  *valuep = -value;
+  return 0;
+}
+
 static const char *
 parse_signed8 (CGEN_CPU_DESC cd, const char **strp,
               int opindex, signed long *valuep)
 {
   const char *errmsg = 0;
 static const char *
 parse_signed8 (CGEN_CPU_DESC cd, const char **strp,
               int opindex, signed long *valuep)
 {
   const char *errmsg = 0;
-  signed long value;
-  
-  /* Don't successfully parse literals beginning with '[' */
-  if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
+  signed long value = 0;
 
 
-  errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
-  if (errmsg)
-    return errmsg;
+  if (strncasecmp (*strp, "%hi8(", 5) == 0)
+    {
+      enum cgen_parse_operand_result result_type;
+      bfd_vma val;
+
+      *strp += 5;
+      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32C_HI8,
+                                  & result_type, & val);
+      if (**strp != ')')
+       return _("missing `)'");
+      (*strp) ++;
+
+      if (errmsg == NULL
+         && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+       val >>= 16;
+
+      value = val;
+      *valuep = value;
+      return errmsg;
+    }
+
+  PARSE_SIGNED;
 
   if (value <= 255 && value > 127)
     value -= 0x100;
 
   if (value <= 255 && value > 127)
     value -= 0x100;
@@ -223,16 +292,37 @@ parse_unsigned16 (CGEN_CPU_DESC cd, const char **strp,
                 int opindex, unsigned long *valuep)
 {
   const char *errmsg = 0;
                 int opindex, unsigned long *valuep)
 {
   const char *errmsg = 0;
-  unsigned long value;
+  unsigned long value = 0;
   long have_zero = 0;
   long have_zero = 0;
- 
-  /* Don't successfully parse literals beginning with '[' */
+
+  if (strncasecmp (*strp, "%dsp16(", 7) == 0)
+    {
+      enum cgen_parse_operand_result result_type;
+      bfd_vma val;
+
+      *strp += 7;
+      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_16,
+                                  & result_type, & val);
+      if (**strp != ')')
+       return _("missing `)'");
+      (*strp) ++;
+
+      if (errmsg == NULL
+         && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+       return _("%dsp16() takes a symbolic address, not a number");
+
+      value = val;
+      *valuep = value;
+      return errmsg;
+    }
+
+  /* Don't successfully parse literals beginning with '['.  */
   if (**strp == '[')
   if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
+    return "Invalid literal"; /* Anything -- will not be seen.  */
 
 
-  /* Don't successfully parse register names */
+  /* Don't successfully parse register names.  */
   if (m32c_cgen_isa_register (strp))
   if (m32c_cgen_isa_register (strp))
-    return "Invalid literal"; /* anything -- will not be seen */
+    return "Invalid literal"; /* Anything -- will not be seen.  */
 
   if (strncmp (*strp, "0x0", 3) == 0 
       || (**strp == '0' && *(*strp + 1) != 'x'))
 
   if (strncmp (*strp, "0x0", 3) == 0 
       || (**strp == '0' && *(*strp + 1) != 'x'))
@@ -261,15 +351,51 @@ parse_signed16 (CGEN_CPU_DESC cd, const char **strp,
               int opindex, signed long *valuep)
 {
   const char *errmsg = 0;
               int opindex, signed long *valuep)
 {
   const char *errmsg = 0;
-  signed long value;
-  
-  /* Don't successfully parse literals beginning with '[' */
-  if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
+  signed long value = 0;
 
 
-  errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
-  if (errmsg)
-    return errmsg;
+  if (strncasecmp (*strp, "%lo16(", 6) == 0)
+    {
+      enum cgen_parse_operand_result result_type;
+      bfd_vma val;
+
+      *strp += 6;
+      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LO16,
+                                  & result_type, & val);
+      if (**strp != ')')
+       return _("missing `)'");
+      (*strp) ++;
+
+      if (errmsg == NULL
+         && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+       val &= 0xffff;
+
+      value = val;
+      *valuep = value;
+      return errmsg;
+    }
+
+  if (strncasecmp (*strp, "%hi16(", 6) == 0)
+    {
+      enum cgen_parse_operand_result result_type;
+      bfd_vma val;
+
+      *strp += 6;
+      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_HI16,
+                                  & result_type, & val);
+      if (**strp != ')')
+       return _("missing `)'");
+      (*strp) ++;
+
+      if (errmsg == NULL
+         && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
+       val >>= 16;
+
+      value = val;
+      *valuep = value;
+      return errmsg;
+    }
+
+  PARSE_SIGNED;
 
   if (value <= 65535 && value > 32767)
     value -= 0x10000;
 
   if (value <= 65535 && value > 32767)
     value -= 0x10000;
@@ -288,13 +414,13 @@ parse_unsigned20 (CGEN_CPU_DESC cd, const char **strp,
   const char *errmsg = 0;
   unsigned long value;
   
   const char *errmsg = 0;
   unsigned long value;
   
-  /* Don't successfully parse literals beginning with '[' */
+  /* Don't successfully parse literals beginning with '['.  */
   if (**strp == '[')
   if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
+    return "Invalid literal"; /* Anything -- will not be seen.  */
 
 
-  /* Don't successfully parse register names */
+  /* Don't successfully parse register names.  */
   if (m32c_cgen_isa_register (strp))
   if (m32c_cgen_isa_register (strp))
-    return "Invalid literal"; /* anything -- will not be seen */
+    return "Invalid literal"; /* Anything -- will not be seen.  */
 
   errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
   if (errmsg)
 
   errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
   if (errmsg)
@@ -314,13 +440,13 @@ parse_unsigned24 (CGEN_CPU_DESC cd, const char **strp,
   const char *errmsg = 0;
   unsigned long value;
   
   const char *errmsg = 0;
   unsigned long value;
   
-  /* Don't successfully parse literals beginning with '[' */
+  /* Don't successfully parse literals beginning with '['.  */
   if (**strp == '[')
   if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
+    return "Invalid literal"; /* Anything -- will not be seen.  */
 
 
-  /* Don't successfully parse register names */
+  /* Don't successfully parse register names.  */
   if (m32c_cgen_isa_register (strp))
   if (m32c_cgen_isa_register (strp))
-    return "Invalid literal"; /* anything -- will not be seen */
+    return "Invalid literal"; /* Anything -- will not be seen.  */
 
   errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
   if (errmsg)
 
   errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
   if (errmsg)
@@ -333,23 +459,33 @@ parse_unsigned24 (CGEN_CPU_DESC cd, const char **strp,
   return 0;
 }
 
   return 0;
 }
 
+/* This should only be used for #imm->reg.  */
 static const char *
 static const char *
-parse_signed32 (CGEN_CPU_DESC cd, const char **strp,
+parse_signed24 (CGEN_CPU_DESC cd, const char **strp,
                 int opindex, signed long *valuep)
 {
   const char *errmsg = 0;
   signed long value;
                 int opindex, signed long *valuep)
 {
   const char *errmsg = 0;
   signed long value;
-  
-#if 0
-  /* Don't successfully parse literals beginning with '[' */
-  if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
 
 
-  /* Don't successfully parse register names */
-  if (m32c_cgen_isa_register (strp))
-    return "Invalid literal"; /* anything -- will not be seen */
-#endif
+  PARSE_SIGNED;
+
+  if (value <= 0xffffff && value > 0x7fffff)
+    value -= 0x1000000;
+
+  if (value > 0xffffff)
+    return _("dsp:24 immediate is out of range");
+
+  *valuep = value;
+  return 0;
+}
 
 
+static const char *
+parse_signed32 (CGEN_CPU_DESC cd, const char **strp,
+               int opindex, signed long *valuep)
+{
+  const char *errmsg = 0;
+  signed long value;
+  
   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
   if (errmsg)
     return errmsg;
   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
   if (errmsg)
     return errmsg;
@@ -364,18 +500,8 @@ parse_imm1_S (CGEN_CPU_DESC cd, const char **strp,
 {
   const char *errmsg = 0;
   signed long value;
 {
   const char *errmsg = 0;
   signed long value;
-  
-#if 0
-  /* Don't successfully parse literals beginning with '[' */
-  if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
 
 
-  /* Don't successfully parse register names */
-  if (m32c_cgen_isa_register (strp))
-    return "Invalid literal"; /* anything -- will not be seen */
-#endif
-
-  errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
+  errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
   if (errmsg)
     return errmsg;
 
   if (errmsg)
     return errmsg;
 
@@ -393,17 +519,7 @@ parse_imm3_S (CGEN_CPU_DESC cd, const char **strp,
   const char *errmsg = 0;
   signed long value;
   
   const char *errmsg = 0;
   signed long value;
   
-#if 0
-  /* Don't successfully parse literals beginning with '[' */
-  if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
-
-  /* Don't successfully parse register names */
-  if (m32c_cgen_isa_register (strp))
-    return "Invalid literal"; /* anything -- will not be seen */
-#endif
-
-  errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
+  errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
   if (errmsg)
     return errmsg;
 
   if (errmsg)
     return errmsg;
 
@@ -414,6 +530,60 @@ parse_imm3_S (CGEN_CPU_DESC cd, const char **strp,
   return 0;
 }
 
   return 0;
 }
 
+static const char *
+parse_bit3_S (CGEN_CPU_DESC cd, const char **strp,
+            int opindex, signed long *valuep)
+{
+  const char *errmsg = 0;
+  signed long value;
+  
+  errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
+  if (errmsg)
+    return errmsg;
+
+  if (value < 0 || value > 7)
+    return _("immediate is out of range 0-7");
+
+  *valuep = value;
+  return 0;
+}
+
+static const char *
+parse_lab_5_3 (CGEN_CPU_DESC cd,
+              const char **strp,
+              int opindex ATTRIBUTE_UNUSED,
+              int opinfo,
+              enum cgen_parse_operand_result *type_addr,
+              bfd_vma *valuep)
+{
+  const char *errmsg = 0;
+  bfd_vma value;
+  enum cgen_parse_operand_result op_res;
+
+  errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_5_3,
+                              opinfo, & op_res, & value);
+
+  if (type_addr)
+    *type_addr = op_res;
+
+  if (op_res == CGEN_PARSE_OPERAND_RESULT_QUEUED)
+    {
+      /* This is a hack; the field cannot handle near-zero signed
+        offsets that CGEN wants to put in to indicate an "empty"
+        operand at first.  */
+      *valuep = 2;
+      return 0;
+    }
+  if (errmsg)
+    return errmsg;
+
+  if (value < 2 || value > 9)
+    return _("immediate is out of range 2-9");
+
+  *valuep = value;
+  return 0;
+}
+
 static const char *
 parse_Bitno16R (CGEN_CPU_DESC cd, const char **strp,
                int opindex, unsigned long *valuep)
 static const char *
 parse_Bitno16R (CGEN_CPU_DESC cd, const char **strp,
                int opindex, unsigned long *valuep)
@@ -421,12 +591,6 @@ parse_Bitno16R (CGEN_CPU_DESC cd, const char **strp,
   const char *errmsg = 0;
   unsigned long value;
 
   const char *errmsg = 0;
   unsigned long value;
 
-#if 0
-  /* Don't successfully parse literals beginning with '[' */
-  if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
-#endif
-
   errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
   if (errmsg)
     return errmsg;
   errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
   if (errmsg)
     return errmsg;
@@ -441,19 +605,14 @@ parse_Bitno16R (CGEN_CPU_DESC cd, const char **strp,
 static const char *
 parse_unsigned_bitbase (CGEN_CPU_DESC cd, const char **strp,
                        int opindex, unsigned long *valuep,
 static const char *
 parse_unsigned_bitbase (CGEN_CPU_DESC cd, const char **strp,
                        int opindex, unsigned long *valuep,
-                       unsigned bits)
+                       unsigned bits, int allow_syms)
 {
   const char *errmsg = 0;
   unsigned long bit;
   unsigned long base;
   const char *newp = *strp;
   unsigned long long bitbase;
 {
   const char *errmsg = 0;
   unsigned long bit;
   unsigned long base;
   const char *newp = *strp;
   unsigned long long bitbase;
-
-#if 0
-  /* Don't successfully parse literals beginning with '[' */
-  if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
-#endif
+  long have_zero = 0;
 
   errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit);
   if (errmsg)
 
   errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit);
   if (errmsg)
@@ -463,15 +622,35 @@ parse_unsigned_bitbase (CGEN_CPU_DESC cd, const char **strp,
     return "Missing base for bit,base:8";
 
   ++newp;
     return "Missing base for bit,base:8";
 
   ++newp;
+
+  if (strncmp (newp, "0x0", 3) == 0 
+      || (newp[0] == '0' && newp[1] != 'x'))
+    have_zero = 1;
+
   errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & base);
   if (errmsg)
     return errmsg;
 
   errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & base);
   if (errmsg)
     return errmsg;
 
-  bitbase = (unsigned long long)bit + ((unsigned long long)base * 8);
+  bitbase = (unsigned long long) bit + ((unsigned long long) base * 8);
 
   if (bitbase >= (1ull << bits))
     return _("bit,base is out of range");
 
 
   if (bitbase >= (1ull << bits))
     return _("bit,base is out of range");
 
+  /* If this field may require a relocation then use larger displacement.  */
+  if (! have_zero && base == 0)
+    {
+      switch (allow_syms) {
+      case 0:
+       return _("bit,base out of range for symbol");
+      case 1:
+       break;
+      case 2:
+       if (strncmp (newp, "[sb]", 4) != 0)
+         return _("bit,base out of range for symbol");
+       break;
+      }
+    }
+
   *valuep = bitbase;
   *strp = newp;
   return 0;
   *valuep = bitbase;
   *strp = newp;
   return 0;
@@ -480,7 +659,7 @@ parse_unsigned_bitbase (CGEN_CPU_DESC cd, const char **strp,
 static const char *
 parse_signed_bitbase (CGEN_CPU_DESC cd, const char **strp,
                      int opindex, signed long *valuep,
 static const char *
 parse_signed_bitbase (CGEN_CPU_DESC cd, const char **strp,
                      int opindex, signed long *valuep,
-                     unsigned bits)
+                     unsigned bits, int allow_syms)
 {
   const char *errmsg = 0;
   unsigned long bit;
 {
   const char *errmsg = 0;
   unsigned long bit;
@@ -488,12 +667,7 @@ parse_signed_bitbase (CGEN_CPU_DESC cd, const char **strp,
   const char *newp = *strp;
   long long bitbase;
   long long limit;
   const char *newp = *strp;
   long long bitbase;
   long long limit;
-
-#if 0
-  /* Don't successfully parse literals beginning with '[' */
-  if (**strp == '[')
-    return "Invalid literal"; /* anything -- will not be seen */
-#endif
+  long have_zero = 0;
 
   errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit);
   if (errmsg)
 
   errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit);
   if (errmsg)
@@ -503,6 +677,11 @@ parse_signed_bitbase (CGEN_CPU_DESC cd, const char **strp,
     return "Missing base for bit,base:8";
 
   ++newp;
     return "Missing base for bit,base:8";
 
   ++newp;
+
+  if (strncmp (newp, "0x0", 3) == 0 
+      || (newp[0] == '0' && newp[1] != 'x'))
+    have_zero = 1;
+
   errmsg = cgen_parse_signed_integer (cd, & newp, opindex, & base);
   if (errmsg)
     return errmsg;
   errmsg = cgen_parse_signed_integer (cd, & newp, opindex, & base);
   if (errmsg)
     return errmsg;
@@ -513,6 +692,10 @@ parse_signed_bitbase (CGEN_CPU_DESC cd, const char **strp,
   if (bitbase < -limit || bitbase >= limit)
     return _("bit,base is out of range");
 
   if (bitbase < -limit || bitbase >= limit)
     return _("bit,base is out of range");
 
+  /* If this field may require a relocation then use larger displacement.  */
+  if (! have_zero && base == 0 && ! allow_syms)
+    return _("bit,base out of range for symbol");
+
   *valuep = bitbase;
   *strp = newp;
   return 0;
   *valuep = bitbase;
   *strp = newp;
   return 0;
@@ -522,74 +705,75 @@ static const char *
 parse_unsigned_bitbase8 (CGEN_CPU_DESC cd, const char **strp,
                         int opindex, unsigned long *valuep)
 {
 parse_unsigned_bitbase8 (CGEN_CPU_DESC cd, const char **strp,
                         int opindex, unsigned long *valuep)
 {
-  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 8);
+  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 8, 0);
 }
 
 static const char *
 parse_unsigned_bitbase11 (CGEN_CPU_DESC cd, const char **strp,
                         int opindex, unsigned long *valuep)
 {
 }
 
 static const char *
 parse_unsigned_bitbase11 (CGEN_CPU_DESC cd, const char **strp,
                         int opindex, unsigned long *valuep)
 {
-  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 11);
+  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 11, 0);
 }
 
 static const char *
 parse_unsigned_bitbase16 (CGEN_CPU_DESC cd, const char **strp,
                          int opindex, unsigned long *valuep)
 {
 }
 
 static const char *
 parse_unsigned_bitbase16 (CGEN_CPU_DESC cd, const char **strp,
                          int opindex, unsigned long *valuep)
 {
-  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 16);
+  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 16, 1);
 }
 
 static const char *
 parse_unsigned_bitbase19 (CGEN_CPU_DESC cd, const char **strp,
                         int opindex, unsigned long *valuep)
 {
 }
 
 static const char *
 parse_unsigned_bitbase19 (CGEN_CPU_DESC cd, const char **strp,
                         int opindex, unsigned long *valuep)
 {
-  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 19);
+  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 19, 2);
 }
 
 static const char *
 parse_unsigned_bitbase27 (CGEN_CPU_DESC cd, const char **strp,
                         int opindex, unsigned long *valuep)
 {
 }
 
 static const char *
 parse_unsigned_bitbase27 (CGEN_CPU_DESC cd, const char **strp,
                         int opindex, unsigned long *valuep)
 {
-  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 27);
+  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 27, 1);
 }
 
 static const char *
 parse_signed_bitbase8 (CGEN_CPU_DESC cd, const char **strp,
                       int opindex, signed long *valuep)
 {
 }
 
 static const char *
 parse_signed_bitbase8 (CGEN_CPU_DESC cd, const char **strp,
                       int opindex, signed long *valuep)
 {
-  return parse_signed_bitbase (cd, strp, opindex, valuep, 8);
+  return parse_signed_bitbase (cd, strp, opindex, valuep, 8, 1);
 }
 
 static const char *
 parse_signed_bitbase11 (CGEN_CPU_DESC cd, const char **strp,
                       int opindex, signed long *valuep)
 {
 }
 
 static const char *
 parse_signed_bitbase11 (CGEN_CPU_DESC cd, const char **strp,
                       int opindex, signed long *valuep)
 {
-  return parse_signed_bitbase (cd, strp, opindex, valuep, 11);
+  return parse_signed_bitbase (cd, strp, opindex, valuep, 11, 0);
 }
 
 static const char *
 parse_signed_bitbase19 (CGEN_CPU_DESC cd, const char **strp,
                       int opindex, signed long *valuep)
 {
 }
 
 static const char *
 parse_signed_bitbase19 (CGEN_CPU_DESC cd, const char **strp,
                       int opindex, signed long *valuep)
 {
-  return parse_signed_bitbase (cd, strp, opindex, valuep, 19);
+  return parse_signed_bitbase (cd, strp, opindex, valuep, 19, 1);
 }
 
 /* Parse the suffix as :<char> or as nothing followed by a whitespace.  */
 }
 
 /* Parse the suffix as :<char> or as nothing followed by a whitespace.  */
+
 static const char *
 parse_suffix (const char **strp, char suffix)
 {
   const char *newp = *strp;
   
 static const char *
 parse_suffix (const char **strp, char suffix)
 {
   const char *newp = *strp;
   
-  if (**strp == ':' && tolower (*(*strp + 1)) == suffix)
+  if (**strp == ':' && TOLOWER (*(*strp + 1)) == suffix)
     newp = *strp + 2;
 
     newp = *strp + 2;
 
-  if (isspace (*newp))
+  if (ISSPACE (*newp))
     {
       *strp = newp;
       return 0;
     }
        
     {
       *strp = newp;
       return 0;
     }
        
-  return "Invalid suffix"; /* anything -- will not be seen */
+  return "Invalid suffix"; /* Anything -- will not be seen.  */
 }
 
 static const char *
 }
 
 static const char *
@@ -621,6 +805,7 @@ parse_Z (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
 }
 
 /* Parse an empty suffix. Fail if the next char is ':'.  */
 }
 
 /* Parse an empty suffix. Fail if the next char is ':'.  */
+
 static const char *
 parse_X (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
         int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
 static const char *
 parse_X (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
         int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
@@ -639,16 +824,16 @@ parse_r0l_r0h (CGEN_CPU_DESC cd, const char **strp,
   signed long junk;
   const char *newp = *strp;
 
   signed long junk;
   const char *newp = *strp;
 
-  /* Parse r0[hl] */
+  /* Parse r0[hl].  */
   errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0l_r0h, & value);
   if (errmsg)
     return errmsg;
 
   if (*newp != ',')
   errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0l_r0h, & value);
   if (errmsg)
     return errmsg;
 
   if (*newp != ',')
-    return "not a valid r0l/r0h pair";
+    return _("not a valid r0l/r0h pair");
   ++newp;
 
   ++newp;
 
-  /* Parse the second register in the pair */
+  /* Parse the second register in the pair.  */
   if (value == 0) /* r0l */
     errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0h, & junk);
   else
   if (value == 0) /* r0l */
     errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0h, & junk);
   else
@@ -661,7 +846,8 @@ parse_r0l_r0h (CGEN_CPU_DESC cd, const char **strp,
   return 0;
 }
 
   return 0;
 }
 
-/* Accept .b or .w in any case */
+/* Accept .b or .w in any case.  */
+
 static const char *
 parse_size (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
            int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
 static const char *
 parse_size (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
            int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
@@ -671,196 +857,14 @@ parse_size (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
          || *(*strp + 1) == 'w' || *(*strp + 1) == 'W'))
     {
       *strp += 2;
          || *(*strp + 1) == 'w' || *(*strp + 1) == 'W'))
     {
       *strp += 2;
-      return 0;
+      return NULL;
     }
     }
-  return "Invalid size specifier";
+
+  return _("Invalid size specifier");
 }
 
 }
 
-/* static const char * parse_abs (CGEN_CPU_DESC, const char **, int, */
-/*                            unsigned long *, unsigned long); */
-/* static const char * parse_abs16 (CGEN_CPU_DESC, const char **, int, */
-/*                              int ATTRIBUTE_UNUSED, */
-/*                              enum cgen_parse_operand_result * ATTRIBUTE_UNUSED, */
-/*                              unsigned long * ); */
-/* static const char * parse_abs24 (CGEN_CPU_DESC, const char **, int, */
-/*                              int ATTRIBUTE_UNUSED, */
-/*                              enum cgen_parse_operand_result  * ATTRIBUTE_UNUSED, */
-/*                              unsigned long *); */
-
-/* /\* Parse absolute  *\/ */
-
-/* static const char * */
-/* parse_abs16 (CGEN_CPU_DESC cd, const char **strp, int opindex, */
-/*          int reloc ATTRIBUTE_UNUSED, */
-/*          enum cgen_parse_operand_result *type_addr ATTRIBUTE_UNUSED, */
-/*          unsigned long *valuep) */
-/* { */
-/*   return parse_abs (cd, strp, opindex, valuep, 16); */
-/* } */
-
-/* static const char * */
-/* parse_abs24 (CGEN_CPU_DESC cd, const char **strp, int opindex, */
-/*          int reloc ATTRIBUTE_UNUSED, */
-/*          enum cgen_parse_operand_result *type_addr ATTRIBUTE_UNUSED, */
-/*          unsigned long *valuep) */
-/* { */
-/*   return parse_abs (cd, strp, opindex, valuep, 24); */
-/* } */
-
-/* static const char * */
-/* parse_abs (CGEN_CPU_DESC cd, const char **strp, int opindex, */
-/*        unsigned long *valuep, */
-/*        unsigned long length) */
-/* { */
-/*   const char *errmsg = 0; */
-/*   const char *op; */
-/*   int has_register = 0; */
-    
-/*   for (op = *strp; *op != '\0'; op++) */
-/*     { */
-/*       if (*op == '[') */
-/*     { */
-/*       has_register = 1; */
-/*       break; */
-/*     } */
-/*       else if (*op == ',') */
-/*     break; */
-/*     } */
-  
-/*   if (has_register || m32c_cgen_isa_register (strp)) */
-/*     errmsg = _("immediate value cannot be register"); */
-/*   else */
-/*     { */
-/*       enum cgen_parse_operand_result result_type; */
-/*       bfd_vma value; */
-/*       const char *errmsg; */
- 
-/*       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_HI16, */
-/*                                    &result_type, &value); */
-/*       *valuep = value; */
-/*     } */
-/*   return errmsg; */
-/* } */
-/* /\* Handle signed/unsigned literal.  *\/ */
-
-/* static const char * */
-/* parse_imm8 (cd, strp, opindex, valuep) */
-/*      CGEN_CPU_DESC cd; */
-/*      const char **strp; */
-/*      int opindex; */
-/*      unsigned long *valuep; */
-/* { */
-/*   const char *errmsg = 0; */
-/*   long value; */
-/*   long have_zero = 0; */
-  
-/*   if (strncmp (*strp, "0x0", 3) == 0  */
-/*       || (**strp == '0' && *(*strp + 1) != 'x')) */
-/*     have_zero = 1; */
-/*   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); */
-/*   *valuep = value; */
-/*   /\* If this field may require a relocation then use larger dsp16.  *\/ */
-/*   if (! have_zero && value == 0) */
-/*     errmsg = _("immediate value may not fit in dsp8 field"); */
-    
-/*   return errmsg; */
-/* } */
-
-/* static const char * */
-/* parse_imm16 (cd, strp, opindex, valuep) */
-/*      CGEN_CPU_DESC cd; */
-/*      const char **strp; */
-/*      int opindex; */
-/*      unsigned long *valuep; */
-/* { */
-/*   const char *errmsg; */
-/*   long value; */
- 
-/*   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); */
-/*   *valuep = value; */
-/*   return errmsg; */
-/* } */
-
-/* static const char * */
-/* parse_imm24 (cd, strp, opindex, valuep) */
-/*      CGEN_CPU_DESC cd; */
-/*      const char **strp; */
-/*      int opindex; */
-/*      unsigned long *valuep; */
-/* { */
-/*   const char *errmsg; */
-/*   long value; */
- 
-/*   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); */
-/*   *valuep = value; */
-/*   return errmsg; */
-/* } */
-
-/* static const char * */
-/* parse_imm32 (cd, strp, opindex, valuep) */
-/*      CGEN_CPU_DESC cd; */
-/*      const char **strp; */
-/*      int opindex; */
-/*      unsigned long *valuep; */
-/* { */
-/*   const char *errmsg; */
-/*   long value; */
- 
-/*   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); */
-/*   *valuep = value; */
-/*   return errmsg; */
-/* } */
-
-/* /\* Handle bitfields.  *\/ */
-
-/* static const char * */
-/* parse_boff8 (cd, strp, opindex, valuep) */
-/*      CGEN_CPU_DESC cd; */
-/*      const char **strp; */
-/*      int opindex; */
-/*      unsigned long *valuep; */
-/* { */
-/*   const char *errmsg; */
-/*   long bit_value, value; */
- 
-/*   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & bit_value); */
-/*   if (errmsg == 0) */
-/*     { */
-/*       *strp = *strp + 1; */
-/*       errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); */
-/*     } */
-/*   value = value * 8 + bit_value; */
-/*   *valuep = value; */
-/*   if (value > 0x100) */
-/*     errmsg = _("Operand out of range. Must be between 0 and 255."); */
-/*   return errmsg; */
-/* } */
-
-/* static const char * */
-/* parse_boff16 (cd, strp, opindex, valuep) */
-/*      CGEN_CPU_DESC cd; */
-/*      const char **strp; */
-/*      int opindex; */
-/*      unsigned long *valuep; */
-/* { */
-/*   const char *errmsg; */
-/*   long bit_value, value; */
- 
-/*   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & bit_value); */
-/*   if (errmsg == 0) */
-/*     { */
-/*       *strp = *strp + 1; */
-/*       errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value); */
-/*     } */
-/*   value = value * 8 + bit_value; */
-/*   *valuep = value; */
-/*   if (value > 0x1000) */
-/*     errmsg = _("Operand out of range. Must be between 0 and 65535."); */
-/*   return errmsg; */
-/* } */
-
-
-/* Special check to ensure that instruction exists for given machine */
+/* Special check to ensure that instruction exists for given machine.  */
+
 int
 m32c_cgen_insn_supported (CGEN_CPU_DESC cd,
                          const CGEN_INSN *insn)
 int
 m32c_cgen_insn_supported (CGEN_CPU_DESC cd,
                          const CGEN_INSN *insn)
@@ -868,12 +872,12 @@ m32c_cgen_insn_supported (CGEN_CPU_DESC cd,
   int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH);
   CGEN_BITSET isas = CGEN_INSN_BITSET_ATTR_VALUE (insn, CGEN_INSN_ISA);
 
   int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH);
   CGEN_BITSET isas = CGEN_INSN_BITSET_ATTR_VALUE (insn, CGEN_INSN_ISA);
 
-  /* If attributes are absent, assume no restriction. */
+  /* If attributes are absent, assume no restriction.  */
   if (machs == 0)
     machs = ~0;
 
   if (machs == 0)
     machs = ~0;
 
-  return (machs & cd->machs)
-    && cgen_bitset_intersect_p (& isas, cd->isas);
+  return ((machs & cd->machs)
+          && cgen_bitset_intersect_p (& isas, cd->isas));
 }
 
 /* Parse a set of registers, R0,R1,A0,A1,SB,FB.  */
 }
 
 /* Parse a set of registers, R0,R1,A0,A1,SB,FB.  */
@@ -883,8 +887,7 @@ parse_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
              const char **strp,
              int opindex ATTRIBUTE_UNUSED,
              unsigned long *valuep,
              const char **strp,
              int opindex ATTRIBUTE_UNUSED,
              unsigned long *valuep,
-             int push
-             )
+             int push)
 {
   const char *errmsg = 0;
   int regno = 0;
 {
   const char *errmsg = 0;
   int regno = 0;
@@ -940,23 +943,23 @@ parse_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
   return errmsg;
 }
 
   return errmsg;
 }
 
-#define POP 0
+#define POP  0
 #define PUSH 1
 
 static const char *
 parse_pop_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 #define PUSH 1
 
 static const char *
 parse_pop_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-                    const char **strp,
-                    int opindex ATTRIBUTE_UNUSED,
-                    unsigned long *valuep)
+                 const char **strp,
+                 int opindex ATTRIBUTE_UNUSED,
+                 unsigned long *valuep)
 {
   return parse_regset (cd, strp, opindex, valuep, POP);
 }
 
 static const char *
 parse_push_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 {
   return parse_regset (cd, strp, opindex, valuep, POP);
 }
 
 static const char *
 parse_push_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-                    const char **strp,
-                    int opindex ATTRIBUTE_UNUSED,
-                    unsigned long *valuep)
+                  const char **strp,
+                  int opindex ATTRIBUTE_UNUSED,
+                  unsigned long *valuep)
 {
   return parse_regset (cd, strp, opindex, valuep, PUSH);
 }
 {
   return parse_regset (cd, strp, opindex, valuep, PUSH);
 }
@@ -966,17 +969,19 @@ parse_push_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 #include "elf/m32c.h"
 #include "elf-bfd.h"
 
 #include "elf/m32c.h"
 #include "elf-bfd.h"
 
-/* Always print the short insn format suffix as ':<char>' */
+/* Always print the short insn format suffix as ':<char>'.  */
+
 static void
 static void
-print_suffix (PTR dis_info, char suffix)
+print_suffix (void * dis_info, char suffix)
 {
   disassemble_info *info = dis_info;
 {
   disassemble_info *info = dis_info;
+
   (*info->fprintf_func) (info->stream, ":%c", suffix);
 }
 
 static void
 print_S (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
   (*info->fprintf_func) (info->stream, ":%c", suffix);
 }
 
 static void
 print_S (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-        PTR dis_info,
+        void * dis_info,
         long value ATTRIBUTE_UNUSED,
         unsigned int attrs ATTRIBUTE_UNUSED,
         bfd_vma pc ATTRIBUTE_UNUSED,
         long value ATTRIBUTE_UNUSED,
         unsigned int attrs ATTRIBUTE_UNUSED,
         bfd_vma pc ATTRIBUTE_UNUSED,
@@ -988,7 +993,7 @@ print_S (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
 static void
 print_G (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
 static void
 print_G (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-        PTR dis_info,
+        void * dis_info,
         long value ATTRIBUTE_UNUSED,
         unsigned int attrs ATTRIBUTE_UNUSED,
         bfd_vma pc ATTRIBUTE_UNUSED,
         long value ATTRIBUTE_UNUSED,
         unsigned int attrs ATTRIBUTE_UNUSED,
         bfd_vma pc ATTRIBUTE_UNUSED,
@@ -999,7 +1004,7 @@ print_G (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
 static void
 print_Q (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
 static void
 print_Q (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-        PTR dis_info,
+        void * dis_info,
         long value ATTRIBUTE_UNUSED,
         unsigned int attrs ATTRIBUTE_UNUSED,
         bfd_vma pc ATTRIBUTE_UNUSED,
         long value ATTRIBUTE_UNUSED,
         unsigned int attrs ATTRIBUTE_UNUSED,
         bfd_vma pc ATTRIBUTE_UNUSED,
@@ -1010,7 +1015,7 @@ print_Q (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
 static void
 print_Z (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
 static void
 print_Z (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-        PTR dis_info,
+        void * dis_info,
         long value ATTRIBUTE_UNUSED,
         unsigned int attrs ATTRIBUTE_UNUSED,
         bfd_vma pc ATTRIBUTE_UNUSED,
         long value ATTRIBUTE_UNUSED,
         unsigned int attrs ATTRIBUTE_UNUSED,
         bfd_vma pc ATTRIBUTE_UNUSED,
@@ -1019,10 +1024,11 @@ print_Z (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
   print_suffix (dis_info, 'z');
 }
 
   print_suffix (dis_info, 'z');
 }
 
-/* Print the empty suffix */
+/* Print the empty suffix.  */
+
 static void
 print_X (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 static void
 print_X (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-        PTR dis_info ATTRIBUTE_UNUSED,
+        void * dis_info ATTRIBUTE_UNUSED,
         long value ATTRIBUTE_UNUSED,
         unsigned int attrs ATTRIBUTE_UNUSED,
         bfd_vma pc ATTRIBUTE_UNUSED,
         long value ATTRIBUTE_UNUSED,
         unsigned int attrs ATTRIBUTE_UNUSED,
         bfd_vma pc ATTRIBUTE_UNUSED,
@@ -1033,13 +1039,14 @@ print_X (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
 static void
 print_r0l_r0h (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
 static void
 print_r0l_r0h (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-              PTR dis_info,
+              void * dis_info,
               long value,
               unsigned int attrs ATTRIBUTE_UNUSED,
               bfd_vma pc ATTRIBUTE_UNUSED,
               int length ATTRIBUTE_UNUSED)
 {
   disassemble_info *info = dis_info;
               long value,
               unsigned int attrs ATTRIBUTE_UNUSED,
               bfd_vma pc ATTRIBUTE_UNUSED,
               int length ATTRIBUTE_UNUSED)
 {
   disassemble_info *info = dis_info;
+
   if (value == 0)
     (*info->fprintf_func) (info->stream, "r0h,r0l");
   else
   if (value == 0)
     (*info->fprintf_func) (info->stream, "r0h,r0l");
   else
@@ -1048,65 +1055,68 @@ print_r0l_r0h (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
 static void
 print_unsigned_bitbase (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
 static void
 print_unsigned_bitbase (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-                       PTR dis_info,
+                       void * dis_info,
                        unsigned long value,
                        unsigned int attrs ATTRIBUTE_UNUSED,
                        bfd_vma pc ATTRIBUTE_UNUSED,
                        int length ATTRIBUTE_UNUSED)
 {
   disassemble_info *info = dis_info;
                        unsigned long value,
                        unsigned int attrs ATTRIBUTE_UNUSED,
                        bfd_vma pc ATTRIBUTE_UNUSED,
                        int length ATTRIBUTE_UNUSED)
 {
   disassemble_info *info = dis_info;
+
   (*info->fprintf_func) (info->stream, "%ld,0x%lx", value & 0x7, value >> 3);
 }
 
 static void
 print_signed_bitbase (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
   (*info->fprintf_func) (info->stream, "%ld,0x%lx", value & 0x7, value >> 3);
 }
 
 static void
 print_signed_bitbase (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-                     PTR dis_info,
+                     void * dis_info,
                      signed long value,
                      unsigned int attrs ATTRIBUTE_UNUSED,
                      bfd_vma pc ATTRIBUTE_UNUSED,
                      int length ATTRIBUTE_UNUSED)
 {
   disassemble_info *info = dis_info;
                      signed long value,
                      unsigned int attrs ATTRIBUTE_UNUSED,
                      bfd_vma pc ATTRIBUTE_UNUSED,
                      int length ATTRIBUTE_UNUSED)
 {
   disassemble_info *info = dis_info;
+
   (*info->fprintf_func) (info->stream, "%ld,%ld", value & 0x7, value >> 3);
 }
 
 static void
 print_size (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
   (*info->fprintf_func) (info->stream, "%ld,%ld", value & 0x7, value >> 3);
 }
 
 static void
 print_size (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-           PTR dis_info,
+           void * dis_info,
            long value ATTRIBUTE_UNUSED,
            unsigned int attrs ATTRIBUTE_UNUSED,
            bfd_vma pc ATTRIBUTE_UNUSED,
            int length ATTRIBUTE_UNUSED)
 {
            long value ATTRIBUTE_UNUSED,
            unsigned int attrs ATTRIBUTE_UNUSED,
            bfd_vma pc ATTRIBUTE_UNUSED,
            int length ATTRIBUTE_UNUSED)
 {
-  /* Always print the size as '.w' */
+  /* Always print the size as '.w'.  */
   disassemble_info *info = dis_info;
   disassemble_info *info = dis_info;
+
   (*info->fprintf_func) (info->stream, ".w");
 }
 
   (*info->fprintf_func) (info->stream, ".w");
 }
 
-#define POP 0
+#define POP  0
 #define PUSH 1
 
 #define PUSH 1
 
-static void print_pop_regset (CGEN_CPU_DESC, PTR, long, unsigned int, bfd_vma, int);
-static void print_push_regset (CGEN_CPU_DESC, PTR, long, unsigned int, bfd_vma, int);
+static void print_pop_regset  (CGEN_CPU_DESC, void *, long, unsigned int, bfd_vma, int);
+static void print_push_regset (CGEN_CPU_DESC, void *, long, unsigned int, bfd_vma, int);
 
 /* Print a set of registers, R0,R1,A0,A1,SB,FB.  */
 
 static void
 print_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
 /* Print a set of registers, R0,R1,A0,A1,SB,FB.  */
 
 static void
 print_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-               PTR dis_info,
-               long value,
-               unsigned int attrs ATTRIBUTE_UNUSED,
-               bfd_vma pc ATTRIBUTE_UNUSED,
-               int length ATTRIBUTE_UNUSED,
-               int push)
+             void * dis_info,
+             long value,
+             unsigned int attrs ATTRIBUTE_UNUSED,
+             bfd_vma pc ATTRIBUTE_UNUSED,
+             int length ATTRIBUTE_UNUSED,
+             int push)
 {
   static char * m16c_register_names [] = 
 {
   static char * m16c_register_names [] = 
-    {
-      "r0", "r1", "r2", "r3", "a0", "a1", "sb", "fb"
-    };
+  {
+    "r0", "r1", "r2", "r3", "a0", "a1", "sb", "fb"
+  };
   disassemble_info *info = dis_info;
   int mask;
   disassemble_info *info = dis_info;
   int mask;
-  int index = 0;
+  int reg_index = 0;
   char* comma = "";
 
   if (push)
   char* comma = "";
 
   if (push)
@@ -1120,7 +1130,7 @@ print_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
       comma = ",";
     }
 
       comma = ",";
     }
 
-  for (index = 1; index <= 7; ++index)
+  for (reg_index = 1; reg_index <= 7; ++reg_index)
     {
       if (push)
         mask >>= 1;
     {
       if (push)
         mask >>= 1;
@@ -1130,7 +1140,7 @@ print_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
       if (value & mask)
         {
           (*info->fprintf_func) (info->stream, "%s%s", comma,
       if (value & mask)
         {
           (*info->fprintf_func) (info->stream, "%s%s", comma,
-                                m16c_register_names [index]);
+                                m16c_register_names [reg_index]);
           comma = ",";
         }
     }
           comma = ",";
         }
     }
@@ -1138,38 +1148,35 @@ print_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
 static void
 print_pop_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
 static void
 print_pop_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-                   PTR dis_info,
-                   long value,
-                   unsigned int attrs ATTRIBUTE_UNUSED,
-                   bfd_vma pc ATTRIBUTE_UNUSED,
-                   int length ATTRIBUTE_UNUSED)
+                 void * dis_info,
+                 long value,
+                 unsigned int attrs ATTRIBUTE_UNUSED,
+                 bfd_vma pc ATTRIBUTE_UNUSED,
+                 int length ATTRIBUTE_UNUSED)
 {
   print_regset (cd, dis_info, value, attrs, pc, length, POP);
 }
 
 static void
 print_push_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 {
   print_regset (cd, dis_info, value, attrs, pc, length, POP);
 }
 
 static void
 print_push_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-                    PTR dis_info,
-                    long value,
-                    unsigned int attrs ATTRIBUTE_UNUSED,
-                    bfd_vma pc ATTRIBUTE_UNUSED,
-                    int length ATTRIBUTE_UNUSED)
+                  void * dis_info,
+                  long value,
+                  unsigned int attrs ATTRIBUTE_UNUSED,
+                  bfd_vma pc ATTRIBUTE_UNUSED,
+                  int length ATTRIBUTE_UNUSED)
 {
   print_regset (cd, dis_info, value, attrs, pc, length, PUSH);
 }
 {
   print_regset (cd, dis_info, value, attrs, pc, length, PUSH);
 }
-#if 0 /* not used? */
+
 static void
 static void
-print_boff (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
-                    PTR dis_info,
-                    long value,
-                    unsigned int attrs ATTRIBUTE_UNUSED,
-                    bfd_vma pc ATTRIBUTE_UNUSED,
-                    int length ATTRIBUTE_UNUSED)
+print_signed4n (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
+               void * dis_info,
+               signed long value,
+               unsigned int attrs ATTRIBUTE_UNUSED,
+               bfd_vma pc ATTRIBUTE_UNUSED,
+               int length ATTRIBUTE_UNUSED)
 {
   disassemble_info *info = dis_info;
 {
   disassemble_info *info = dis_info;
-  if (value)
-    info->fprintf_func (info->stream, "%d,%d", value % 16,
-                       (value / 16) * 2);
-}
 
 
-#endif /* not used? */
+  (*info->fprintf_func) (info->stream, "%ld", -value);
+}
GDB Binutils - Deliverables
This page took 0.039467 seconds and 4 git commands to generate.