lookup_constraint is also an out-of-line switch-based function.
Since most constraints are still single-letter ones, it should be
more efficient to have a lookup array for the single-character case
and an out-of-line function for the more complicated ones.  This becomes
even more important with the latter half of the series (which isn't as
much of a win otherwise).

Richard


gcc/
        * genpreds.c (write_lookup_constraint): Rename to...
        (write_lookup_constraint_1): ...this.
        (write_lookup_constraint_array): New function.
        (write_tm_preds_h): Define lookup_constraint as an inline function
        that uses write_lookup_constraint_array where possible.
        (write_insn_preds_c): Update for the changes above.

Index: gcc/genpreds.c
===================================================================
--- gcc/genpreds.c      2014-06-05 21:05:45.308958640 +0100
+++ gcc/genpreds.c      2014-06-05 21:05:45.972964371 +0100
@@ -966,11 +966,11 @@ write_enum_constraint_num (void)
 /* Write out a function which looks at a string and determines what
    constraint name, if any, it begins with.  */
 static void
-write_lookup_constraint (void)
+write_lookup_constraint_1 (void)
 {
   unsigned int i;
   puts ("enum constraint_num\n"
-       "lookup_constraint (const char *str)\n"
+       "lookup_constraint_1 (const char *str)\n"
        "{\n"
        "  switch (str[0])\n"
        "    {");
@@ -1005,6 +1005,29 @@ write_lookup_constraint (void)
        "}\n");
 }
 
+/* Write out an array that maps single-letter characters to their
+   constraints (if that fits in a character) or 255 if lookup_constraint_1
+   must be called.  */
+static void
+write_lookup_constraint_array (void)
+{
+  unsigned int i;
+  printf ("const unsigned char lookup_constraint_array[] = {\n  ");
+  for (i = 0; i < ARRAY_SIZE (constraints_by_letter_table); i++)
+    {
+      if (i != 0)
+       printf (",\n  ");
+      struct constraint_data *c = constraints_by_letter_table[i];
+      if (!c)
+       printf ("CONSTRAINT__UNKNOWN");
+      else if (c->namelen == 1)
+       printf ("MIN ((int) CONSTRAINT_%s, (int) UCHAR_MAX)", c->c_name);
+      else
+       printf ("UCHAR_MAX");
+    }
+  printf ("\n};\n\n");
+}
+
 /* Write out a function which looks at a string and determines what
    the constraint name length is.  */
 static void
@@ -1245,7 +1268,22 @@ #define GCC_TM_PREDS_H\n\
   if (constraint_max_namelen > 0)
     {
       write_enum_constraint_num ();
-      puts ("extern enum constraint_num lookup_constraint (const char *);");
+      puts ("extern enum constraint_num lookup_constraint_1 (const char *);\n"
+           "extern const unsigned char lookup_constraint_array[];\n"
+           "\n"
+           "/* Return the constraint at the beginning of P, or"
+           " CONSTRAINT__UNKNOWN if it\n"
+           "   isn't recognized.  */\n"
+           "\n"
+           "static inline enum constraint_num\n"
+           "lookup_constraint (const char *p)\n"
+           "{\n"
+           "  unsigned int index = lookup_constraint_array"
+           "[(unsigned char) *p];\n"
+           "  return (index == UCHAR_MAX\n"
+           "          ? lookup_constraint_1 (p)\n"
+           "          : (enum constraint_num) index);\n"
+           "}\n");
       if (satisfied_start == num_constraints)
        puts ("/* Return true if X satisfies constraint C.  */\n"
              "\n"
@@ -1383,7 +1421,8 @@ write_insn_preds_c (void)
 
   if (constraint_max_namelen > 0)
     {
-      write_lookup_constraint ();
+      write_lookup_constraint_1 ();
+      write_lookup_constraint_array ();
       if (have_register_constraints)
        write_reg_class_for_constraint_1 ();
       write_constraint_satisfied_p_1 ();

Reply via email to