2003-07-09 Elena Zannoni <ezannoni@redhat.com>

[deliverable/binutils-gdb.git] / opcodes / m32r-ibld.c

diff --git a/opcodes/m32r-ibld.c b/opcodes/m32r-ibld.c
index fa15d7e45140679c2ee7729530f5b26a44fa6833..ef1ee0e01266fff15460c1c0fd37d1ae60b0b343 100644 (file)
--- a/opcodes/m32r-ibld.c
+++ b/opcodes/m32r-ibld.c
@@ -3,7 +3,7 @@
 THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator.
 - the resultant file is machine generated, cgen-ibld.in isn't
 
 THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator.
 - the resultant file is machine generated, cgen-ibld.in isn't
 

-Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
+Copyright 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.

 
 This file is part of the GNU Binutils and GDB, the GNU debugger.
 
 
 This file is part of the GNU Binutils and GDB, the GNU debugger.
 


@@ -25,7 +25,6 @@ along with this program; if not, write to the Free Software Foundation, Inc.,
    Keep that in mind.  */
 
 #include "sysdep.h"
    Keep that in mind.  */
 
 #include "sysdep.h"

-#include <ctype.h>

 #include <stdio.h>
 #include "ansidecl.h"
 #include "dis-asm.h"
 #include <stdio.h>
 #include "ansidecl.h"
 #include "dis-asm.h"


@@ -34,6 +33,7 @@ along with this program; if not, write to the Free Software Foundation, Inc.,
 #include "m32r-desc.h"
 #include "m32r-opc.h"
 #include "opintl.h"
 #include "m32r-desc.h"
 #include "m32r-opc.h"
 #include "opintl.h"

+#include "safe-ctype.h"

 
 #undef min
 #define min(a,b) ((a) < (b) ? (a) : (b))
 
 #undef min
 #define min(a,b) ((a) < (b) ? (a) : (b))


@@ -49,7 +49,6 @@ static const char * insert_normal
 static const char * insert_insn_normal
      PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *,
              CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma));
 static const char * insert_insn_normal
      PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *,
              CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma));

-

 static int extract_normal
      PARAMS ((CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
              unsigned int, unsigned int, unsigned int, unsigned int,
 static int extract_normal
      PARAMS ((CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
              unsigned int, unsigned int, unsigned int, unsigned int,


@@ -57,6 +56,19 @@ static int extract_normal
 static int extract_insn_normal
      PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *,
              CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma));
 static int extract_insn_normal
      PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *,
              CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma));

+#if CGEN_INT_INSN_P
+static void put_insn_int_value
+     PARAMS ((CGEN_CPU_DESC, CGEN_INSN_BYTES_PTR, int, int, CGEN_INSN_INT));
+#endif
+#if ! CGEN_INT_INSN_P
+static CGEN_INLINE void insert_1
+     PARAMS ((CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *));
+static CGEN_INLINE int fill_cache
+     PARAMS ((CGEN_CPU_DESC, CGEN_EXTRACT_INFO *,  int, int, bfd_vma));
+static CGEN_INLINE long extract_1
+     PARAMS ((CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, int,
+             unsigned char *, bfd_vma));
+#endif

 \f
 /* Operand insertion.  */
 
 \f
 /* Operand insertion.  */
 


@@ -73,36 +85,8 @@ insert_1 (cd, value, start, length, word_length, bufp)
 {
   unsigned long x,mask;
   int shift;
 {
   unsigned long x,mask;
   int shift;

-  int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;

 
 

-  switch (word_length)
-    {
-    case 8:
-      x = *bufp;
-      break;
-    case 16:
-      if (big_p)
-       x = bfd_getb16 (bufp);
-      else
-       x = bfd_getl16 (bufp);
-      break;
-    case 24:
-      /* ??? This may need reworking as these cases don't necessarily
-        want the first byte and the last two bytes handled like this.  */
-      if (big_p)
-       x = (bufp[0] << 16) | bfd_getb16 (bufp + 1);
-      else
-       x = bfd_getl16 (bufp) | (bufp[2] << 16);
-      break;
-    case 32:
-      if (big_p)
-       x = bfd_getb32 (bufp);
-      else
-       x = bfd_getl32 (bufp);
-      break;
-    default :
-      abort ();
-    }
+  x = cgen_get_insn_value (cd, bufp, word_length);

 
   /* Written this way to avoid undefined behaviour.  */
   mask = (((1L << (length - 1)) - 1) << 1) | 1;
 
   /* Written this way to avoid undefined behaviour.  */
   mask = (((1L << (length - 1)) - 1) << 1) | 1;


@@ -112,40 +96,7 @@ insert_1 (cd, value, start, length, word_length, bufp)
     shift = (word_length - (start + length));
   x = (x & ~(mask << shift)) | ((value & mask) << shift);
 
     shift = (word_length - (start + length));
   x = (x & ~(mask << shift)) | ((value & mask) << shift);
 

-  switch (word_length)
-    {
-    case 8:
-      *bufp = x;
-      break;
-    case 16:
-      if (big_p)
-       bfd_putb16 (x, bufp);
-      else
-       bfd_putl16 (x, bufp);
-      break;
-    case 24:
-      /* ??? This may need reworking as these cases don't necessarily
-        want the first byte and the last two bytes handled like this.  */
-      if (big_p)
-       {
-         bufp[0] = x >> 16;
-         bfd_putb16 (x, bufp + 1);
-       }
-      else
-       {
-         bfd_putl16 (x, bufp);
-         bufp[2] = x >> 16;
-       }
-      break;
-    case 32:
-      if (big_p)
-       bfd_putb32 (x, bufp);
-      else
-       bfd_putl32 (x, bufp);
-      break;
-    default :
-      abort ();
-    }
+  cgen_put_insn_value (cd, bufp, word_length, (bfd_vma) x);

 }
 
 #endif /* ! CGEN_INT_INSN_P */
 }
 
 #endif /* ! CGEN_INT_INSN_P */


@@ -183,9 +134,11 @@ insert_normal (cd, value, attrs, word_offset, start, length, word_length,
   if (length == 0)
     return NULL;
 
   if (length == 0)
     return NULL;
 

+#if 0

   if (CGEN_INT_INSN_P
       && word_offset != 0)
     abort ();
   if (CGEN_INT_INSN_P
       && word_offset != 0)
     abort ();

+#endif

 
   if (word_length > 32)
     abort ();
 
   if (word_length > 32)
     abort ();


@@ -200,9 +153,25 @@ insert_normal (cd, value, attrs, word_offset, start, length, word_length,
     }
 
   /* Ensure VALUE will fit.  */
     }
 
   /* Ensure VALUE will fit.  */

-  if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED))
+  if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT))

     {
     {

+      long minval = - (1L << (length - 1));

       unsigned long maxval = mask;
       unsigned long maxval = mask;

+      
+      if ((value > 0 && (unsigned long) value > maxval)
+         || value < minval)
+       {
+         /* xgettext:c-format */
+         sprintf (errbuf,
+                  _("operand out of range (%ld not between %ld and %lu)"),
+                  value, minval, maxval);
+         return errbuf;
+       }
+    }
+  else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED))
+    {
+      unsigned long maxval = mask;
+      

       if ((unsigned long) value > maxval)
        {
          /* xgettext:c-format */
       if ((unsigned long) value > maxval)
        {
          /* xgettext:c-format */


@@ -214,15 +183,19 @@ insert_normal (cd, value, attrs, word_offset, start, length, word_length,
     }
   else
     {
     }
   else
     {

-      long minval = - (1L << (length - 1));
-      long maxval = (1L << (length - 1)) - 1;
-      if (value < minval || value > maxval)
+      if (! cgen_signed_overflow_ok_p (cd))

        {
        {

-         sprintf
-           /* xgettext:c-format */
-           (errbuf, _("operand out of range (%ld not between %ld and %ld)"),
-            value, minval, maxval);
-         return errbuf;
+         long minval = - (1L << (length - 1));
+         long maxval =   (1L << (length - 1)) - 1;
+         
+         if (value < minval || value > maxval)
+           {
+             sprintf
+               /* xgettext:c-format */
+               (errbuf, _("operand out of range (%ld not between %ld and %ld)"),
+                value, minval, maxval);
+             return errbuf;
+           }

        }
     }
 
        }
     }
 


@@ -232,9 +205,9 @@ insert_normal (cd, value, attrs, word_offset, start, length, word_length,
     int shift;
 
     if (CGEN_INSN_LSB0_P)
     int shift;
 
     if (CGEN_INSN_LSB0_P)

-      shift = (start + 1) - length;
+      shift = (word_offset + start + 1) - length;

     else
     else

-      shift = word_length - (start + length);
+      shift = total_length - (word_offset + start + length);

     *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift);
   }
 
     *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift);
   }
 


@@ -252,10 +225,10 @@ insert_normal (cd, value, attrs, word_offset, start, length, word_length,
 }
 
 /* Default insn builder (insert handler).
 }
 
 /* Default insn builder (insert handler).

-   The instruction is recorded in CGEN_INT_INSN_P byte order
-   (meaning that if CGEN_INT_INSN_P BUFFER is an int * and thus the value is
-   recorded in host byte order, otherwise BUFFER is an array of bytes and the
-   value is recorded in target byte order).
+   The instruction is recorded in CGEN_INT_INSN_P byte order (meaning
+   that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is
+   recorded in host byte order, otherwise BUFFER is an array of bytes
+   and the value is recorded in target byte order).

    The result is an error message or NULL if success.  */
 
 static const char *
    The result is an error message or NULL if success.  */
 
 static const char *


@@ -268,7 +241,7 @@ insert_insn_normal (cd, insn, fields, buffer, pc)
 {
   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
   unsigned long value;
 {
   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
   unsigned long value;

-  const unsigned char * syn;
+  const CGEN_SYNTAX_CHAR_TYPE * syn;

 
   CGEN_INIT_INSERT (cd);
   value = CGEN_INSN_BASE_VALUE (insn);
 
   CGEN_INIT_INSERT (cd);
   value = CGEN_INSN_BASE_VALUE (insn);


@@ -278,12 +251,13 @@ insert_insn_normal (cd, insn, fields, buffer, pc)
 
 #if CGEN_INT_INSN_P
 
 
 #if CGEN_INT_INSN_P
 

-  *buffer = value;
+  put_insn_int_value (cd, buffer, cd->base_insn_bitsize,
+                     CGEN_FIELDS_BITSIZE (fields), value);

 
 #else
 
 
 #else
 

-  cgen_put_insn_value (cd, buffer, min (cd->base_insn_bitsize,
-                                       CGEN_FIELDS_BITSIZE (fields)),
+  cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize,
+                                       (unsigned) CGEN_FIELDS_BITSIZE (fields)),

                       value);
 
 #endif /* ! CGEN_INT_INSN_P */
                       value);
 
 #endif /* ! CGEN_INT_INSN_P */


@@ -293,7 +267,7 @@ insert_insn_normal (cd, insn, fields, buffer, pc)
      e.g. storing a branch displacement that got resolved later.
      Needs more thought first.  */
 
      e.g. storing a branch displacement that got resolved later.
      Needs more thought first.  */
 

-  for (syn = CGEN_SYNTAX_STRING (syntax); * syn != '\0'; ++ syn)
+  for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn)

     {
       const char *errmsg;
 
     {
       const char *errmsg;
 


@@ -308,6 +282,32 @@ insert_insn_normal (cd, insn, fields, buffer, pc)
 
   return NULL;
 }
 
   return NULL;
 }

+
+#if CGEN_INT_INSN_P
+/* Cover function to store an insn value into an integral insn.  Must go here
+ because it needs <prefix>-desc.h for CGEN_INT_INSN_P.  */
+
+static void
+put_insn_int_value (cd, buf, length, insn_length, value)
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
+     CGEN_INSN_BYTES_PTR buf;
+     int length;
+     int insn_length;
+     CGEN_INSN_INT value;
+{
+  /* For architectures with insns smaller than the base-insn-bitsize,
+     length may be too big.  */
+  if (length > insn_length)
+    *buf = value;
+  else
+    {
+      int shift = insn_length - length;
+      /* Written this way to avoid undefined behaviour.  */
+      CGEN_INSN_INT mask = (((1L << (length - 1)) - 1) << 1) | 1;
+      *buf = (*buf & ~(mask << shift)) | ((value & mask) << shift);
+    }
+}
+#endif

 \f
 /* Operand extraction.  */
 
 \f
 /* Operand extraction.  */
 


@@ -321,14 +321,14 @@ insert_insn_normal (cd, insn, fields, buffer, pc)
 
 static CGEN_INLINE int
 fill_cache (cd, ex_info, offset, bytes, pc)
 
 static CGEN_INLINE int
 fill_cache (cd, ex_info, offset, bytes, pc)

-     CGEN_CPU_DESC cd;
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;

      CGEN_EXTRACT_INFO *ex_info;
      int offset, bytes;
      bfd_vma pc;
 {
   /* It's doubtful that the middle part has already been fetched so
      we don't optimize that case.  kiss.  */
      CGEN_EXTRACT_INFO *ex_info;
      int offset, bytes;
      bfd_vma pc;
 {
   /* It's doubtful that the middle part has already been fetched so
      we don't optimize that case.  kiss.  */

-  int mask;
+  unsigned int mask;

   disassemble_info *info = (disassemble_info *) ex_info->dis_info;
 
   /* First do a quick check.  */
   disassemble_info *info = (disassemble_info *) ex_info->dis_info;
 
   /* First do a quick check.  */


@@ -366,51 +366,23 @@ fill_cache (cd, ex_info, offset, bytes, pc)
 static CGEN_INLINE long
 extract_1 (cd, ex_info, start, length, word_length, bufp, pc)
      CGEN_CPU_DESC cd;
 static CGEN_INLINE long
 extract_1 (cd, ex_info, start, length, word_length, bufp, pc)
      CGEN_CPU_DESC cd;

-     CGEN_EXTRACT_INFO *ex_info;
+     CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED;

      int start,length,word_length;
      unsigned char *bufp;
      int start,length,word_length;
      unsigned char *bufp;

-     bfd_vma pc;
+     bfd_vma pc ATTRIBUTE_UNUSED;

 {
 {

-  unsigned long x,mask;
+  unsigned long x;

   int shift;
   int shift;

+#if 0

   int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
   int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;

+#endif
+  x = cgen_get_insn_value (cd, bufp, word_length);

 
 

-  switch (word_length)
-    {
-    case 8:
-      x = *bufp;
-      break;
-    case 16:
-      if (big_p)
-       x = bfd_getb16 (bufp);
-      else
-       x = bfd_getl16 (bufp);
-      break;
-    case 24:
-      /* ??? This may need reworking as these cases don't necessarily
-        want the first byte and the last two bytes handled like this.  */
-      if (big_p)
-       x = (bufp[0] << 16) | bfd_getb16 (bufp + 1);
-      else
-       x = bfd_getl16 (bufp) | (bufp[2] << 16);
-      break;
-    case 32:
-      if (big_p)
-       x = bfd_getb32 (bufp);
-      else
-       x = bfd_getl32 (bufp);
-      break;
-    default :
-      abort ();
-    }
-
-  /* Written this way to avoid undefined behaviour.  */
-  mask = (((1L << (length - 1)) - 1) << 1) | 1;

   if (CGEN_INSN_LSB0_P)
     shift = (start + 1) - length;
   else
     shift = (word_length - (start + length));
   if (CGEN_INSN_LSB0_P)
     shift = (start + 1) - length;
   else
     shift = (word_length - (start + length));

-  return (x >> shift) & mask;
+  return x >> shift;

 }
 
 #endif /* ! CGEN_INT_INSN_P */
 }
 
 #endif /* ! CGEN_INT_INSN_P */


@@ -439,14 +411,22 @@ static int
 extract_normal (cd, ex_info, insn_value, attrs, word_offset, start, length,
                word_length, total_length, pc, valuep)
      CGEN_CPU_DESC cd;
 extract_normal (cd, ex_info, insn_value, attrs, word_offset, start, length,
                word_length, total_length, pc, valuep)
      CGEN_CPU_DESC cd;

+#if ! CGEN_INT_INSN_P

      CGEN_EXTRACT_INFO *ex_info;
      CGEN_EXTRACT_INFO *ex_info;

+#else
+     CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED;
+#endif

      CGEN_INSN_INT insn_value;
      unsigned int attrs;
      unsigned int word_offset, start, length, word_length, total_length;
      CGEN_INSN_INT insn_value;
      unsigned int attrs;
      unsigned int word_offset, start, length, word_length, total_length;

+#if ! CGEN_INT_INSN_P

      bfd_vma pc;
      bfd_vma pc;

+#else
+     bfd_vma pc ATTRIBUTE_UNUSED;
+#endif

      long *valuep;
 {
      long *valuep;
 {

-  CGEN_INSN_INT value;
+  long value, mask;

 
   /* If LENGTH is zero, this operand doesn't contribute to the value
      so give it a standard value of zero.  */
 
   /* If LENGTH is zero, this operand doesn't contribute to the value
      so give it a standard value of zero.  */


@@ -456,9 +436,11 @@ extract_normal (cd, ex_info, insn_value, attrs, word_offset, start, length,
       return 1;
     }
 
       return 1;
     }
 

+#if 0

   if (CGEN_INT_INSN_P
       && word_offset != 0)
     abort ();
   if (CGEN_INT_INSN_P
       && word_offset != 0)
     abort ();

+#endif

 
   if (word_length > 32)
     abort ();
 
   if (word_length > 32)
     abort ();


@@ -472,22 +454,14 @@ extract_normal (cd, ex_info, insn_value, attrs, word_offset, start, length,
        word_length = total_length;
     }
 
        word_length = total_length;
     }
 

-  /* Does the value reside in INSN_VALUE?  */
+  /* Does the value reside in INSN_VALUE, and at the right alignment?  */

 
 

-  if (word_offset == 0)
+  if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length))

     {
     {

-      /* Written this way to avoid undefined behaviour.  */
-      CGEN_INSN_INT mask = (((1L << (length - 1)) - 1) << 1) | 1;
-

       if (CGEN_INSN_LSB0_P)
       if (CGEN_INSN_LSB0_P)

-       value = insn_value >> ((start + 1) - length);
+       value = insn_value >> ((word_offset + start + 1) - length);

       else
       else

-       value = insn_value >> (word_length - (start + length));
-      value &= mask;
-      /* sign extend? */
-      if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
-         && (value & (1L << (length - 1))))
-       value |= ~mask;
+       value = insn_value >> (total_length - ( word_offset + start + length));

     }
 
 #if ! CGEN_INT_INSN_P
     }
 
 #if ! CGEN_INT_INSN_P


@@ -507,6 +481,15 @@ extract_normal (cd, ex_info, insn_value, attrs, word_offset, start, length,
 
 #endif /* ! CGEN_INT_INSN_P */
 
 
 #endif /* ! CGEN_INT_INSN_P */
 

+  /* Written this way to avoid undefined behaviour.  */
+  mask = (((1L << (length - 1)) - 1) << 1) | 1;
+
+  value &= mask;
+  /* sign extend? */
+  if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
+      && (value & (1L << (length - 1))))
+    value |= ~mask;
+

   *valuep = value;
 
   return 1;
   *valuep = value;
 
   return 1;


@@ -531,7 +514,7 @@ extract_insn_normal (cd, insn, ex_info, insn_value, fields, pc)
      bfd_vma pc;
 {
   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
      bfd_vma pc;
 {
   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);

-  const unsigned char *syn;
+  const CGEN_SYNTAX_CHAR_TYPE *syn;

 
   CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
 
 
   CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
 


@@ -556,6 +539,9 @@ extract_insn_normal (cd, insn, ex_info, insn_value, fields, pc)
 \f
 /* machine generated code added here */
 
 \f
 /* machine generated code added here */
 

+const char * m32r_cgen_insert_operand
+  PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma));
+

 /* Main entry point for operand insertion.
 
    This function is basically just a big switch statement.  Earlier versions
 /* Main entry point for operand insertion.
 
    This function is basically just a big switch statement.  Earlier versions


@@ -568,8 +554,7 @@ extract_insn_normal (cd, insn, ex_info, insn_value, fields, pc)
    This function could be moved into `parse_insn_normal', but keeping it
    separate makes clear the interface between `parse_insn_normal' and each of
    the handlers.  It's also needed by GAS to insert operands that couldn't be
    This function could be moved into `parse_insn_normal', but keeping it
    separate makes clear the interface between `parse_insn_normal' and each of
    the handlers.  It's also needed by GAS to insert operands that couldn't be

-   resolved during parsing.
-*/
+   resolved during parsing.  */

 
 const char *
 m32r_cgen_insert_operand (cd, opindex, fields, buffer, pc)
 
 const char *
 m32r_cgen_insert_operand (cd, opindex, fields, buffer, pc)


@@ -577,13 +562,22 @@ m32r_cgen_insert_operand (cd, opindex, fields, buffer, pc)
      int opindex;
      CGEN_FIELDS * fields;
      CGEN_INSN_BYTES_PTR buffer;
      int opindex;
      CGEN_FIELDS * fields;
      CGEN_INSN_BYTES_PTR buffer;

-     bfd_vma pc;
+     bfd_vma pc ATTRIBUTE_UNUSED;

 {
 {

-  const char * errmsg;
+  const char * errmsg = NULL;

   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 
   switch (opindex)
     {
   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 
   switch (opindex)
     {

+    case M32R_OPERAND_ACC :
+      errmsg = insert_normal (cd, fields->f_acc, 0, 0, 8, 1, 32, total_length, buffer);
+      break;
+    case M32R_OPERAND_ACCD :
+      errmsg = insert_normal (cd, fields->f_accd, 0, 0, 4, 2, 32, total_length, buffer);
+      break;
+    case M32R_OPERAND_ACCS :
+      errmsg = insert_normal (cd, fields->f_accs, 0, 0, 12, 2, 32, total_length, buffer);
+      break;

     case M32R_OPERAND_DCR :
       errmsg = insert_normal (cd, fields->f_r1, 0, 0, 4, 4, 32, total_length, buffer);
       break;
     case M32R_OPERAND_DCR :
       errmsg = insert_normal (cd, fields->f_r1, 0, 0, 4, 4, 32, total_length, buffer);
       break;


@@ -612,11 +606,17 @@ m32r_cgen_insert_operand (cd, opindex, fields, buffer, pc)
       errmsg = insert_normal (cd, fields->f_r1, 0, 0, 4, 4, 32, total_length, buffer);
       break;
     case M32R_OPERAND_HASH :
       errmsg = insert_normal (cd, fields->f_r1, 0, 0, 4, 4, 32, total_length, buffer);
       break;
     case M32R_OPERAND_HASH :

-      errmsg = insert_normal (cd, fields->f_nil, 0, 0, 0, 0, 0, total_length, buffer);

       break;
     case M32R_OPERAND_HI16 :
       errmsg = insert_normal (cd, fields->f_hi16, 0|(1<<CGEN_IFLD_SIGN_OPT), 0, 16, 16, 32, total_length, buffer);
       break;
       break;
     case M32R_OPERAND_HI16 :
       errmsg = insert_normal (cd, fields->f_hi16, 0|(1<<CGEN_IFLD_SIGN_OPT), 0, 16, 16, 32, total_length, buffer);
       break;

+    case M32R_OPERAND_IMM1 :
+      {
+        long value = fields->f_imm1;
+        value = ((value) - (1));
+        errmsg = insert_normal (cd, value, 0, 0, 15, 1, 32, total_length, buffer);
+      }
+      break;

     case M32R_OPERAND_SCR :
       errmsg = insert_normal (cd, fields->f_r2, 0, 0, 12, 4, 32, total_length, buffer);
       break;
     case M32R_OPERAND_SCR :
       errmsg = insert_normal (cd, fields->f_r2, 0, 0, 12, 4, 32, total_length, buffer);
       break;


@@ -664,7 +664,13 @@ m32r_cgen_insert_operand (cd, opindex, fields, buffer, pc)
   return errmsg;
 }
 
   return errmsg;
 }
 

+int m32r_cgen_extract_operand
+  PARAMS ((CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
+           CGEN_FIELDS *, bfd_vma));
+

 /* Main entry point for operand extraction.
 /* Main entry point for operand extraction.

+   The result is <= 0 for error, >0 for success.
+   ??? Actual values aren't well defined right now.

 
    This function is basically just a big switch statement.  Earlier versions
    used tables to look up the function to use, but
 
    This function is basically just a big switch statement.  Earlier versions
    used tables to look up the function to use, but


@@ -675,8 +681,7 @@ m32r_cgen_insert_operand (cd, opindex, fields, buffer, pc)
 
    This function could be moved into `print_insn_normal', but keeping it
    separate makes clear the interface between `print_insn_normal' and each of
 
    This function could be moved into `print_insn_normal', but keeping it
    separate makes clear the interface between `print_insn_normal' and each of

-   the handlers.
-*/
+   the handlers.  */

 
 int
 m32r_cgen_extract_operand (cd, opindex, ex_info, insn_value, fields, pc)
 
 int
 m32r_cgen_extract_operand (cd, opindex, ex_info, insn_value, fields, pc)


@@ -687,11 +692,21 @@ m32r_cgen_extract_operand (cd, opindex, ex_info, insn_value, fields, pc)
      CGEN_FIELDS * fields;
      bfd_vma pc;
 {
      CGEN_FIELDS * fields;
      bfd_vma pc;
 {

-  int length;
+  /* Assume success (for those operands that are nops).  */
+  int length = 1;

   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 
   switch (opindex)
     {
   unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
 
   switch (opindex)
     {

+    case M32R_OPERAND_ACC :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 1, 32, total_length, pc, & fields->f_acc);
+      break;
+    case M32R_OPERAND_ACCD :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 2, 32, total_length, pc, & fields->f_accd);
+      break;
+    case M32R_OPERAND_ACCS :
+      length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 2, 32, total_length, pc, & fields->f_accs);
+      break;

     case M32R_OPERAND_DCR :
       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_r1);
       break;
     case M32R_OPERAND_DCR :
       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_r1);
       break;


@@ -723,11 +738,18 @@ m32r_cgen_extract_operand (cd, opindex, ex_info, insn_value, fields, pc)
       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_r1);
       break;
     case M32R_OPERAND_HASH :
       length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_r1);
       break;
     case M32R_OPERAND_HASH :

-      length = extract_normal (cd, ex_info, insn_value, 0, 0, 0, 0, 0, total_length, pc, & fields->f_nil);

       break;
     case M32R_OPERAND_HI16 :
       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGN_OPT), 0, 16, 16, 32, total_length, pc, & fields->f_hi16);
       break;
       break;
     case M32R_OPERAND_HI16 :
       length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGN_OPT), 0, 16, 16, 32, total_length, pc, & fields->f_hi16);
       break;

+    case M32R_OPERAND_IMM1 :
+      {
+        long value;
+        length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 1, 32, total_length, pc, & value);
+        value = ((value) + (1));
+        fields->f_imm1 = value;
+      }
+      break;

     case M32R_OPERAND_SCR :
       length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 4, 32, total_length, pc, & fields->f_r2);
       break;
     case M32R_OPERAND_SCR :
       length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 4, 32, total_length, pc, & fields->f_r2);
       break;


@@ -785,6 +807,11 @@ cgen_extract_fn * const m32r_cgen_extract_handlers[] =
   extract_insn_normal,
 };
 
   extract_insn_normal,
 };
 

+int m32r_cgen_get_int_operand
+  PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
+bfd_vma m32r_cgen_get_vma_operand
+  PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *));
+

 /* Getting values from cgen_fields is handled by a collection of functions.
    They are distinguished by the type of the VALUE argument they return.
    TODO: floating point, inlining support, remove cases where result type
 /* Getting values from cgen_fields is handled by a collection of functions.
    They are distinguished by the type of the VALUE argument they return.
    TODO: floating point, inlining support, remove cases where result type


@@ -792,7 +819,7 @@ cgen_extract_fn * const m32r_cgen_extract_handlers[] =
 
 int
 m32r_cgen_get_int_operand (cd, opindex, fields)
 
 int
 m32r_cgen_get_int_operand (cd, opindex, fields)

-     CGEN_CPU_DESC cd;
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;

      int opindex;
      const CGEN_FIELDS * fields;
 {
      int opindex;
      const CGEN_FIELDS * fields;
 {


@@ -800,6 +827,15 @@ m32r_cgen_get_int_operand (cd, opindex, fields)
 
   switch (opindex)
     {
 
   switch (opindex)
     {

+    case M32R_OPERAND_ACC :
+      value = fields->f_acc;
+      break;
+    case M32R_OPERAND_ACCD :
+      value = fields->f_accd;
+      break;
+    case M32R_OPERAND_ACCS :
+      value = fields->f_accs;
+      break;

     case M32R_OPERAND_DCR :
       value = fields->f_r1;
       break;
     case M32R_OPERAND_DCR :
       value = fields->f_r1;
       break;


@@ -816,11 +852,14 @@ m32r_cgen_get_int_operand (cd, opindex, fields)
       value = fields->f_r1;
       break;
     case M32R_OPERAND_HASH :
       value = fields->f_r1;
       break;
     case M32R_OPERAND_HASH :

-      value = fields->f_nil;
+      value = 0;

       break;
     case M32R_OPERAND_HI16 :
       value = fields->f_hi16;
       break;
       break;
     case M32R_OPERAND_HI16 :
       value = fields->f_hi16;
       break;

+    case M32R_OPERAND_IMM1 :
+      value = fields->f_imm1;
+      break;

     case M32R_OPERAND_SCR :
       value = fields->f_r2;
       break;
     case M32R_OPERAND_SCR :
       value = fields->f_r2;
       break;


@@ -870,7 +909,7 @@ m32r_cgen_get_int_operand (cd, opindex, fields)
 
 bfd_vma
 m32r_cgen_get_vma_operand (cd, opindex, fields)
 
 bfd_vma
 m32r_cgen_get_vma_operand (cd, opindex, fields)

-     CGEN_CPU_DESC cd;
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;

      int opindex;
      const CGEN_FIELDS * fields;
 {
      int opindex;
      const CGEN_FIELDS * fields;
 {


@@ -878,6 +917,15 @@ m32r_cgen_get_vma_operand (cd, opindex, fields)
 
   switch (opindex)
     {
 
   switch (opindex)
     {

+    case M32R_OPERAND_ACC :
+      value = fields->f_acc;
+      break;
+    case M32R_OPERAND_ACCD :
+      value = fields->f_accd;
+      break;
+    case M32R_OPERAND_ACCS :
+      value = fields->f_accs;
+      break;

     case M32R_OPERAND_DCR :
       value = fields->f_r1;
       break;
     case M32R_OPERAND_DCR :
       value = fields->f_r1;
       break;


@@ -894,11 +942,14 @@ m32r_cgen_get_vma_operand (cd, opindex, fields)
       value = fields->f_r1;
       break;
     case M32R_OPERAND_HASH :
       value = fields->f_r1;
       break;
     case M32R_OPERAND_HASH :

-      value = fields->f_nil;
+      value = 0;

       break;
     case M32R_OPERAND_HI16 :
       value = fields->f_hi16;
       break;
       break;
     case M32R_OPERAND_HI16 :
       value = fields->f_hi16;
       break;

+    case M32R_OPERAND_IMM1 :
+      value = fields->f_imm1;
+      break;

     case M32R_OPERAND_SCR :
       value = fields->f_r2;
       break;
     case M32R_OPERAND_SCR :
       value = fields->f_r2;
       break;


@@ -946,6 +997,11 @@ m32r_cgen_get_vma_operand (cd, opindex, fields)
   return value;
 }
 
   return value;
 }
 

+void m32r_cgen_set_int_operand
+  PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, int));
+void m32r_cgen_set_vma_operand
+  PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma));
+

 /* Stuffing values in cgen_fields is handled by a collection of functions.
    They are distinguished by the type of the VALUE argument they accept.
    TODO: floating point, inlining support, remove cases where argument type
 /* Stuffing values in cgen_fields is handled by a collection of functions.
    They are distinguished by the type of the VALUE argument they accept.
    TODO: floating point, inlining support, remove cases where argument type


@@ -953,13 +1009,22 @@ m32r_cgen_get_vma_operand (cd, opindex, fields)
 
 void
 m32r_cgen_set_int_operand (cd, opindex, fields, value)
 
 void
 m32r_cgen_set_int_operand (cd, opindex, fields, value)

-     CGEN_CPU_DESC cd;
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;

      int opindex;
      CGEN_FIELDS * fields;
      int value;
 {
   switch (opindex)
     {
      int opindex;
      CGEN_FIELDS * fields;
      int value;
 {
   switch (opindex)
     {

+    case M32R_OPERAND_ACC :
+      fields->f_acc = value;
+      break;
+    case M32R_OPERAND_ACCD :
+      fields->f_accd = value;
+      break;
+    case M32R_OPERAND_ACCS :
+      fields->f_accs = value;
+      break;

     case M32R_OPERAND_DCR :
       fields->f_r1 = value;
       break;
     case M32R_OPERAND_DCR :
       fields->f_r1 = value;
       break;


@@ -976,11 +1041,13 @@ m32r_cgen_set_int_operand (cd, opindex, fields, value)
       fields->f_r1 = value;
       break;
     case M32R_OPERAND_HASH :
       fields->f_r1 = value;
       break;
     case M32R_OPERAND_HASH :

-      fields->f_nil = value;

       break;
     case M32R_OPERAND_HI16 :
       fields->f_hi16 = value;
       break;
       break;
     case M32R_OPERAND_HI16 :
       fields->f_hi16 = value;
       break;

+    case M32R_OPERAND_IMM1 :
+      fields->f_imm1 = value;
+      break;

     case M32R_OPERAND_SCR :
       fields->f_r2 = value;
       break;
     case M32R_OPERAND_SCR :
       fields->f_r2 = value;
       break;


@@ -1028,13 +1095,22 @@ m32r_cgen_set_int_operand (cd, opindex, fields, value)
 
 void
 m32r_cgen_set_vma_operand (cd, opindex, fields, value)
 
 void
 m32r_cgen_set_vma_operand (cd, opindex, fields, value)

-     CGEN_CPU_DESC cd;
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;

      int opindex;
      CGEN_FIELDS * fields;
      bfd_vma value;
 {
   switch (opindex)
     {
      int opindex;
      CGEN_FIELDS * fields;
      bfd_vma value;
 {
   switch (opindex)
     {

+    case M32R_OPERAND_ACC :
+      fields->f_acc = value;
+      break;
+    case M32R_OPERAND_ACCD :
+      fields->f_accd = value;
+      break;
+    case M32R_OPERAND_ACCS :
+      fields->f_accs = value;
+      break;

     case M32R_OPERAND_DCR :
       fields->f_r1 = value;
       break;
     case M32R_OPERAND_DCR :
       fields->f_r1 = value;
       break;


@@ -1051,11 +1127,13 @@ m32r_cgen_set_vma_operand (cd, opindex, fields, value)
       fields->f_r1 = value;
       break;
     case M32R_OPERAND_HASH :
       fields->f_r1 = value;
       break;
     case M32R_OPERAND_HASH :

-      fields->f_nil = value;

       break;
     case M32R_OPERAND_HI16 :
       fields->f_hi16 = value;
       break;
       break;
     case M32R_OPERAND_HI16 :
       fields->f_hi16 = value;
       break;

+    case M32R_OPERAND_IMM1 :
+      fields->f_imm1 = value;
+      break;

     case M32R_OPERAND_SCR :
       fields->f_r2 = value;
       break;
     case M32R_OPERAND_SCR :
       fields->f_r2 = value;
       break;