Changeset 609 for branches/GNU/src/binutils/opcodes/fr30-asm.c

Timestamp:

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

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/opcodes/fr30-asm.c (modified) (24 diffs, 1 prop)

branches/GNU/src/binutils/opcodes/fr30-asm.c

@@ -27 +27 @@
 
 #include "sysdep.h"
-#include <ctype.h>
 #include <stdio.h>
 #include "ansidecl.h"
@@ -35 +34 @@
 #include "fr30-opc.h"
 #include "opintl.h"
-
-#undef min
+#include "xregex.h"
+#include "libiberty.h"
+#include "safe-ctype.h"
+
+#undef  min
 #define min(a,b) ((a) < (b) ? (a) : (b))
-#undef max
+#undef  max
 #define max(a,b) ((a) > (b) ? (a) : (b))
 
@@ -45 +47 @@
 
 
-/* -- assembler routines inserted here */
+/* -- assembler routines inserted here.  */
 
 /* -- asm.c */
-/* Handle register lists for LDMx and STMx  */
+/* Handle register lists for LDMx and STMx.  */
+
+static int parse_register_number
+  PARAMS ((const char **));
+static const char * parse_register_list
+  PARAMS ((CGEN_CPU_DESC, const char **, int, unsigned long *, int, int));
+static const char * parse_low_register_list_ld
+  PARAMS ((CGEN_CPU_DESC, const char **, int, unsigned long *));
+static const char * parse_hi_register_list_ld
+  PARAMS ((CGEN_CPU_DESC, const char **, int, unsigned long *));
+static const char * parse_low_register_list_st
+  PARAMS ((CGEN_CPU_DESC, const char **, int, unsigned long *));
+static const char * parse_hi_register_list_st
+  PARAMS ((CGEN_CPU_DESC, const char **, int, unsigned long *));
 
 static int
@@ -56 +71 @@
   int regno;
   if (**strp < '0' || **strp > '9')
-    return -1; /* error */
+    return -1; /* error.  */
   regno = **strp - '0';
   ++*strp;
@@ -71 +86 @@
 static const char *
 parse_register_list (cd, strp, opindex, valuep, high_low, load_store)
-     CGEN_CPU_DESC cd;
+     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
      const char **strp;
-     int opindex;
+     int opindex ATTRIBUTE_UNUSED;
      unsigned long *valuep;
      int high_low;   /* 0 == high, 1 == low */
@@ -79 +94 @@
 {
   int regno;
+
   *valuep = 0;
   while (**strp && **strp != ')')
@@ -97 +113 @@
         regno -= 8;
 
-      if (load_store) /* mask is reversed for store */
+      if (load_store) /* Mask is reversed for store.  */
         *valuep |= 0x80 >> regno;
       else
@@ -158 +174 @@
 /* -- */
 
+const char * fr30_cgen_parse_operand
+  PARAMS ((CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *));
+
 /* Main entry point for operand parsing.
 
@@ -169 +188 @@
    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.
-*/
+   the handlers.  */
 
 const char *
@@ -181 +199 @@
   const char * errmsg = NULL;
   /* Used by scalar operands that still need to be parsed.  */
-  long junk;
+  long junk ATTRIBUTE_UNUSED;
 
   switch (opindex)
@@ -328 +346 @@
 
 
+
+/* Regex construction routine.
+
+   This translates an opcode syntax string into a regex string,
+   by replacing any non-character syntax element (such as an
+   opcode) with the pattern '.*'
+
+   It then compiles the regex and stores it in the opcode, for
+   later use by fr30_cgen_assemble_insn
+
+   Returns NULL for success, an error message for failure.  */
+
+char * 
+fr30_cgen_build_insn_regex (insn)
+     CGEN_INSN *insn;
+{  
+  CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
+  const char *mnem = CGEN_INSN_MNEMONIC (insn);
+  char rxbuf[CGEN_MAX_RX_ELEMENTS];
+  char *rx = rxbuf;
+  const CGEN_SYNTAX_CHAR_TYPE *syn;
+  int reg_err;
+
+  syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
+
+  /* Mnemonics come first in the syntax string.  */
+  if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
+    return _("missing mnemonic in syntax string");
+  ++syn;
+
+  /* Generate a case sensitive regular expression that emulates case
+     insensitive matching in the "C" locale.  We cannot generate a case
+     insensitive regular expression because in Turkish locales, 'i' and 'I'
+     are not equal modulo case conversion.  */
+
+  /* Copy the literal mnemonic out of the insn.  */
+  for (; *mnem; mnem++)
+    {
+      char c = *mnem;
+
+      if (ISALPHA (c))
+        {
+          *rx++ = '[';
+          *rx++ = TOLOWER (c);
+          *rx++ = TOUPPER (c);
+          *rx++ = ']';
+        }
+      else
+        *rx++ = c;
+    }
+
+  /* Copy any remaining literals from the syntax string into the rx.  */
+  for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
+    {
+      if (CGEN_SYNTAX_CHAR_P (* syn)) 
+        {
+          char c = CGEN_SYNTAX_CHAR (* syn);
+
+          switch (c) 
+            {
+              /* Escape any regex metacharacters in the syntax.  */
+            case '.': case '[': case '\\': 
+            case '*': case '^': case '$': 
+
+#ifdef CGEN_ESCAPE_EXTENDED_REGEX
+            case '?': case '{': case '}': 
+            case '(': case ')': case '*':
+            case '|': case '+': case ']':
+#endif
+              *rx++ = '\\';
+              *rx++ = c;
+              break;
+
+            default:
+              if (ISALPHA (c))
+                {
+                  *rx++ = '[';
+                  *rx++ = TOLOWER (c);
+                  *rx++ = TOUPPER (c);
+                  *rx++ = ']';
+                }
+              else
+                *rx++ = c;
+              break;
+            }
+        }
+      else
+        {
+          /* Replace non-syntax fields with globs.  */
+          *rx++ = '.';
+          *rx++ = '*';
+        }
+    }
+
+  /* Trailing whitespace ok.  */
+  * rx++ = '['; 
+  * rx++ = ' '; 
+  * rx++ = '\t'; 
+  * rx++ = ']'; 
+  * rx++ = '*'; 
+
+  /* But anchor it after that.  */
+  * rx++ = '$'; 
+  * rx = '\0';
+
+  CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
+  reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
+
+  if (reg_err == 0) 
+    return NULL;
+  else
+    {
+      static char msg[80];
+
+      regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
+      regfree ((regex_t *) CGEN_INSN_RX (insn));
+      free (CGEN_INSN_RX (insn));
+      (CGEN_INSN_RX (insn)) = NULL;
+      return msg;
+    }
+}
+
+
+
 /* Default insn parser.
 
@@ -339 +481 @@
    expensive in the case of the m68k.  Deal with later.
 
-   Returns NULL for success, an error message for failure.
-*/
+   Returns NULL for success, an error message for failure.  */
 
 static const char *
@@ -354 +495 @@
   const char *errmsg;
   const char *p;
-  const unsigned char * syn;
+  const CGEN_SYNTAX_CHAR_TYPE * syn;
 #ifdef CGEN_MNEMONIC_OPERANDS
   /* FIXME: wip */
@@ -365 +506 @@
      not be called from GAS.  */
   p = CGEN_INSN_MNEMONIC (insn);
-  while (*p && tolower (*p) == tolower (*str))
+  while (*p && TOLOWER (*p) == TOLOWER (*str))
     ++p, ++str;
 
@@ -372 +513 @@
 
 #ifndef CGEN_MNEMONIC_OPERANDS
-  if (* str && !isspace (* str))
+  if (* str && ! ISSPACE (* str))
     return _("unrecognized instruction");
 #endif
@@ -401 +542 @@
           /* FIXME: We also take inappropriate advantage of the fact that
              GAS's input scrubber will remove extraneous blanks.  */
-          if (tolower (*str) == tolower (CGEN_SYNTAX_CHAR (* syn)))
+          if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
             {
 #ifdef CGEN_MNEMONIC_OPERANDS
-              if (* syn == ' ')
+              if (CGEN_SYNTAX_CHAR(* syn) == ' ')
                 past_opcode_p = 1;
 #endif
@@ -410 +551 @@
               ++ str;
             }
-          else
+          else if (*str)
             {
               /* Syntax char didn't match.  Can't be this insn.  */
               static char msg [80];
+
               /* xgettext:c-format */
               sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
-                       *syn, *str);
+                       CGEN_SYNTAX_CHAR(*syn), *str);
+              return msg;
+            }
+          else
+            {
+              /* Ran out of input.  */
+              static char msg [80];
+
+              /* xgettext:c-format */
+              sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
+                       CGEN_SYNTAX_CHAR(*syn));
               return msg;
             }
@@ -423 +575 @@
 
       /* We have an operand of some sort.  */
-      errmsg = fr30_cgen_parse_operand (cd, CGEN_SYNTAX_FIELD (*syn),
+      errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn),
                                           &str, fields);
       if (errmsg)
@@ -433 +585 @@
 
   /* If we're at the end of the syntax string, we're done.  */
-  if (* syn == '\0')
+  if (* syn == 0)
     {
       /* FIXME: For the moment we assume a valid `str' can only contain
@@ -439 +591 @@
          the insn and it is assumed that longer versions of insns appear
          before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3).  */
-      while (isspace (* str))
+      while (ISSPACE (* str))
         ++ str;
 
@@ -484 +636 @@
   const char *start;
   CGEN_INSN_LIST *ilist;
-  const char *tmp_errmsg = NULL;
+  const char *parse_errmsg = NULL;
+  const char *insert_errmsg = NULL;
+  int recognized_mnemonic = 0;
 
   /* Skip leading white space.  */
-  while (isspace (* str))
+  while (ISSPACE (* str))
     ++ str;
 
@@ -495 +649 @@
 
   /* Keep looking until we find a match.  */
-
   start = str;
   for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
     {
       const CGEN_INSN *insn = ilist->insn;
+      recognized_mnemonic = 1;
 
 #ifdef CGEN_VALIDATE_INSN_SUPPORTED 
-      /* not usually needed as unsupported opcodes shouldn't be in the hash lists */
+      /* Not usually needed as unsupported opcodes
+         shouldn't be in the hash lists.  */
       /* Is this insn supported by the selected cpu?  */
       if (! fr30_cgen_insn_supported (cd, insn))
         continue;
 #endif
-
       /* If the RELAX attribute is set, this is an insn that shouldn't be
          chosen immediately.  Instead, it is used during assembler/linker
@@ -516 +670 @@
       str = start;
 
+      /* Skip this insn if str doesn't look right lexically.  */
+      if (CGEN_INSN_RX (insn) != NULL &&
+          regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
+        continue;
+
       /* Allow parse/insert handlers to obtain length of insn.  */
       CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
 
-      tmp_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
-      if (tmp_errmsg != NULL)
+      parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
+      if (parse_errmsg != NULL)
         continue;
 
-      /* ??? 0 is passed for `pc' */
-      tmp_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
-                                              (bfd_vma) 0);
-      if (tmp_errmsg != NULL)
+      /* ??? 0 is passed for `pc'.  */
+      insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
+                                                 (bfd_vma) 0);
+      if (insert_errmsg != NULL)
         continue;
 
@@ -534 +693 @@
     }
 
-  /* Make sure we leave this with something at this point. */
-  if (tmp_errmsg == NULL)
-    tmp_errmsg = "unknown mnemonic";
-
   {
     static char errbuf[150];
-
 #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
-    /* if verbose error messages, use errmsg from CGEN_PARSE_FN */
+    const char *tmp_errmsg;
+
+    /* If requesting verbose error messages, use insert_errmsg.
+       Failing that, use parse_errmsg.  */
+    tmp_errmsg = (insert_errmsg ? insert_errmsg :
+                  parse_errmsg ? parse_errmsg :
+                  recognized_mnemonic ?
+                  _("unrecognized form of instruction") :
+                  _("unrecognized instruction"));
+
     if (strlen (start) > 50)
       /* xgettext:c-format */