- prototype declarations for operand predicates (tm-preds.h)
- function definitions of operand predicates, if defined new-style
(insn-preds.c)
- Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
+ Free Software Foundation, Inc.
This file is part of GCC.
GCC 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, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)
any later version.
GCC is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to
-the Free Software Foundation, 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "bconfig.h"
#include "system.h"
#include "rtl.h"
#include "errors.h"
#include "obstack.h"
+#include "read-md.h"
#include "gensupport.h"
/* Given a predicate expression EXP, from form NAME at line LINENO,
{
if (!ISDIGIT (*p) && !ISLOWER (*p))
{
- message_with_line (lineno, "%s: invalid character in path "
- "string '%s'", name, XSTR (exp, 1));
- have_error = 1;
+ error_with_line (lineno, "%s: invalid character in path "
+ "string '%s'", name, XSTR (exp, 1));
return true;
}
}
return false;
default:
- message_with_line (lineno,
- "%s: cannot use '%s' in a predicate expression",
- name, GET_RTX_NAME (GET_CODE (exp)));
- have_error = 1;
+ error_with_line (lineno,
+ "%s: cannot use '%s' in a predicate expression",
+ name, GET_RTX_NAME (GET_CODE (exp)));
return true;
}
}
static void
process_define_predicate (rtx defn, int lineno)
{
- struct pred_data *pred;
- const char *p;
-
- if (!ISALPHA (XSTR (defn, 0)[0]) && XSTR (defn, 0)[0] != '_')
- goto bad_name;
- for (p = XSTR (defn, 0) + 1; *p; p++)
- if (!ISALNUM (*p) && *p != '_')
- goto bad_name;
-
- if (validate_exp (XEXP (defn, 1), XSTR (defn, 0), lineno))
- return;
-
- pred = XCNEW (struct pred_data);
- pred->name = XSTR (defn, 0);
- pred->exp = XEXP (defn, 1);
- pred->c_block = XSTR (defn, 2);
-
- if (GET_CODE (defn) == DEFINE_SPECIAL_PREDICATE)
- pred->special = true;
-
- add_predicate (pred);
- return;
-
- bad_name:
- message_with_line (lineno,
- "%s: predicate name must be a valid C function name",
- XSTR (defn, 0));
- have_error = 1;
- return;
+ validate_exp (XEXP (defn, 1), XSTR (defn, 0), lineno);
}
/* Given a predicate, if it has an embedded C block, write the block
The only wart is that there's no way to insist on a { } string in
an RTL template, so we have to handle "" strings. */
-
+
static void
write_predicate_subfunction (struct pred_data *p)
{
printf ("static inline int\n"
"%s_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n",
p->name);
- print_rtx_ptr_loc (p->c_block);
+ print_md_ptr_loc (p->c_block);
if (p->c_block[0] == '{')
fputs (p->c_block, stdout);
else
if (q != p && (ISALNUM (q[-1]) || q[-1] == '_'))
return false;
q += strlen (var);
- if (ISALNUM (q[0] || q[0] == '_'))
+ if (ISALNUM (q[0]) || q[0] == '_')
return false;
}
return true;
NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
&& NO_MODE_TEST (XEXP (exp, 1)));
break;
-
+
case IOR:
mark_mode_tests (XEXP (exp, 0));
mark_mode_tests (XEXP (exp, 1));
}
}
+/* Determine whether the expression EXP is a MATCH_CODE that should
+ be written as a switch statement. */
+static bool
+generate_switch_p (rtx exp)
+{
+ return GET_CODE (exp) == MATCH_CODE
+ && strchr (XSTR (exp, 0), ',');
+}
+
/* Given a predicate, work out where in its RTL expression to add
tests for proper modes. Special predicates do not get any such
tests. We try to avoid adding tests when we don't have to; in
switch (GET_CODE (subexp))
{
+ case AND:
+ /* The switch code generation in write_predicate_stmts prefers
+ rtx code tests to be at the top of the expression tree. So
+ push this AND down into the second operand of an existing
+ AND expression. */
+ if (generate_switch_p (XEXP (subexp, 0)))
+ pos = &XEXP (subexp, 1);
+ goto break_loop;
+
case IOR:
{
int test0 = NO_MODE_TEST (XEXP (subexp, 0));
int test1 = NO_MODE_TEST (XEXP (subexp, 1));
-
+
gcc_assert (test0 || test1);
-
+
if (test0 && test1)
goto break_loop;
pos = test0 ? &XEXP (subexp, 0) : &XEXP (subexp, 1);
}
break;
-
+
case IF_THEN_ELSE:
{
int test0 = NO_MODE_TEST (XEXP (subexp, 0));
int test1 = NO_MODE_TEST (XEXP (subexp, 1));
int test2 = NO_MODE_TEST (XEXP (subexp, 2));
-
+
gcc_assert ((test0 && test1) || test2);
-
+
if (test0 && test1 && test2)
goto break_loop;
if (test0 && test1)
pos = &XEXP (subexp, 2);
}
break;
-
+
default:
goto break_loop;
}
putchar (TOUPPER (*code));
code++;
}
-
+
if (*codes == ',')
fputs (" || ", stdout);
}
write_predicate_expr (XEXP (exp, 1));
putchar (')');
break;
-
+
case IOR:
putchar ('(');
write_predicate_expr (XEXP (exp, 0));
}
}
+/* Write the MATCH_CODE expression EXP as a switch statement. */
+
+static void
+write_match_code_switch (rtx exp)
+{
+ const char *codes = XSTR (exp, 0);
+ const char *path = XSTR (exp, 1);
+ const char *code;
+
+ fputs (" switch (GET_CODE (", stdout);
+ write_extract_subexp (path);
+ fputs ("))\n {\n", stdout);
+
+ while ((code = scan_comma_elt (&codes)) != 0)
+ {
+ fputs (" case ", stdout);
+ while (code < codes)
+ {
+ putchar (TOUPPER (*code));
+ code++;
+ }
+ fputs(":\n", stdout);
+ }
+}
+
+/* Given a predicate expression EXP, write out a sequence of stmts
+ to evaluate it. This is similar to write_predicate_expr but can
+ generate efficient switch statements. */
+
+static void
+write_predicate_stmts (rtx exp)
+{
+ switch (GET_CODE (exp))
+ {
+ case MATCH_CODE:
+ if (generate_switch_p (exp))
+ {
+ write_match_code_switch (exp);
+ puts (" return true;\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " return false;");
+ return;
+ }
+ break;
+
+ case AND:
+ if (generate_switch_p (XEXP (exp, 0)))
+ {
+ write_match_code_switch (XEXP (exp, 0));
+ puts (" break;\n"
+ " default:\n"
+ " return false;\n"
+ " }");
+ exp = XEXP (exp, 1);
+ }
+ break;
+
+ case IOR:
+ if (generate_switch_p (XEXP (exp, 0)))
+ {
+ write_match_code_switch (XEXP (exp, 0));
+ puts (" return true;\n"
+ " default:\n"
+ " break;\n"
+ " }");
+ exp = XEXP (exp, 1);
+ }
+ break;
+
+ case NOT:
+ if (generate_switch_p (XEXP (exp, 0)))
+ {
+ write_match_code_switch (XEXP (exp, 0));
+ puts (" return false;\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " return true;");
+ return;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ fputs(" return ",stdout);
+ write_predicate_expr (exp);
+ fputs(";\n", stdout);
+}
+
/* Given a predicate, write out a complete C function to compute it. */
static void
write_one_predicate_function (struct pred_data *p)
/* A normal predicate can legitimately not look at enum machine_mode
if it accepts only CONST_INTs and/or CONST_DOUBLEs. */
- printf ("int\n%s (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n"
- "{\n return ",
+ printf ("int\n%s (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n{\n",
p->name);
- write_predicate_expr (p->exp);
- fputs (";\n}\n\n", stdout);
+ write_predicate_stmts (p->exp);
+ fputs ("}\n\n", stdout);
}
\f
/* Constraints fall into two categories: register constraints
for (iter_ = first_constraint; iter_; iter_ = iter_->next_textual)
/* These letters, and all names beginning with them, are reserved for
- generic constraints. */
-static const char generic_constraint_letters[] = "EFVXgimnoprs";
+ generic constraints.
+ The 'm' constraint is not mentioned here since that constraint
+ letter can be overridden by the back end by defining the
+ TARGET_MEM_CONSTRAINT macro. */
+static const char generic_constraint_letters[] = "EFVXginoprs";
/* Machine-independent code expects that constraints with these
(initial) letters will allow only (a subset of all) CONST_INTs. */
}
obstack_1grow (rtl_obstack, '\0');
- return obstack_finish (rtl_obstack);
+ return XOBFINISH (rtl_obstack, const char *);
}
/* Add one constraint, of any sort, to the tables. NAME is its name;
if (!ISALPHA (name[0]) && name[0] != '_')
{
if (name[1] == '\0')
- message_with_line (lineno, "constraint name '%s' is not "
- "a letter or underscore", name);
+ error_with_line (lineno, "constraint name '%s' is not "
+ "a letter or underscore", name);
else
- message_with_line (lineno, "constraint name '%s' does not begin "
- "with a letter or underscore", name);
- have_error = 1;
+ error_with_line (lineno, "constraint name '%s' does not begin "
+ "with a letter or underscore", name);
return;
}
for (p = name; *p; p++)
need_mangled_name = true;
else
{
- message_with_line (lineno,
- "constraint name '%s' must be composed of "
- "letters, digits, underscores, and "
- "angle brackets", name);
- have_error = 1;
+ error_with_line (lineno,
+ "constraint name '%s' must be composed of "
+ "letters, digits, underscores, and "
+ "angle brackets", name);
return;
}
}
if (strchr (generic_constraint_letters, name[0]))
{
if (name[1] == '\0')
- message_with_line (lineno, "constraint letter '%s' cannot be "
- "redefined by the machine description", name);
+ error_with_line (lineno, "constraint letter '%s' cannot be "
+ "redefined by the machine description", name);
else
- message_with_line (lineno, "constraint name '%s' cannot be defined by "
- "the machine description, as it begins with '%c'",
- name, name[0]);
- have_error = 1;
+ error_with_line (lineno, "constraint name '%s' cannot be defined by "
+ "the machine description, as it begins with '%c'",
+ name, name[0]);
return;
}
-
+
namelen = strlen (name);
slot = &constraints_by_letter_table[(unsigned int)name[0]];
for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
if (!strcmp ((*iter)->name, name))
{
- message_with_line (lineno, "redefinition of constraint '%s'", name);
+ error_with_line (lineno, "redefinition of constraint '%s'", name);
message_with_line ((*iter)->lineno, "previous definition is here");
- have_error = 1;
return;
}
else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
{
- message_with_line (lineno, "defining constraint '%s' here", name);
+ error_with_line (lineno, "defining constraint '%s' here", name);
message_with_line ((*iter)->lineno, "renders constraint '%s' "
"(defined here) a prefix", (*iter)->name);
- have_error = 1;
return;
}
else if (!strncmp ((*iter)->name, name, namelen))
{
- message_with_line (lineno, "constraint '%s' is a prefix", name);
+ error_with_line (lineno, "constraint '%s' is a prefix", name);
message_with_line ((*iter)->lineno, "of constraint '%s' "
"(defined here)", (*iter)->name);
- have_error = 1;
return;
}
}
GET_RTX_NAME (appropriate_code)))
{
if (name[1] == '\0')
- message_with_line (lineno, "constraint letter '%c' is reserved "
- "for %s constraints",
- name[0], GET_RTX_NAME (appropriate_code));
+ error_with_line (lineno, "constraint letter '%c' is reserved "
+ "for %s constraints",
+ name[0], GET_RTX_NAME (appropriate_code));
else
- message_with_line (lineno, "constraint names beginning with '%c' "
- "(%s) are reserved for %s constraints",
- name[0], name,
- GET_RTX_NAME (appropriate_code));
-
- have_error = 1;
+ error_with_line (lineno, "constraint names beginning with '%c' "
+ "(%s) are reserved for %s constraints",
+ name[0], name, GET_RTX_NAME (appropriate_code));
return;
}
if (is_memory)
{
if (name[1] == '\0')
- message_with_line (lineno, "constraint letter '%c' cannot be a "
- "memory constraint", name[0]);
+ error_with_line (lineno, "constraint letter '%c' cannot be a "
+ "memory constraint", name[0]);
else
- message_with_line (lineno, "constraint name '%s' begins with '%c', "
- "and therefore cannot be a memory constraint",
- name, name[0]);
-
- have_error = 1;
+ error_with_line (lineno, "constraint name '%s' begins with '%c', "
+ "and therefore cannot be a memory constraint",
+ name, name[0]);
return;
}
else if (is_address)
{
if (name[1] == '\0')
- message_with_line (lineno, "constraint letter '%c' cannot be a "
- "memory constraint", name[0]);
+ error_with_line (lineno, "constraint letter '%c' cannot be a "
+ "memory constraint", name[0]);
else
- message_with_line (lineno, "constraint name '%s' begins with '%c', "
- "and therefore cannot be a memory constraint",
- name, name[0]);
-
- have_error = 1;
+ error_with_line (lineno, "constraint name '%s' begins with '%c', "
+ "and therefore cannot be a memory constraint",
+ name, name[0]);
return;
}
-
- /* Remove the redundant (and (match_code "const_(int|double)")
- from the expression. */
- exp = XEXP (exp, 1);
}
-
- c = obstack_alloc (rtl_obstack, sizeof (struct constraint_data));
+
+ c = XOBNEW (rtl_obstack, struct constraint_data);
c->name = name;
c->c_name = need_mangled_name ? mangle (name) : name;
c->lineno = lineno;
{
struct constraint_data *c;
+ fputs ("#define CONSTRAINT_NUM_DEFINED_P 1\n", stdout);
fputs ("enum constraint_num\n"
"{\n"
" CONSTRAINT__UNKNOWN = 0", stdout);
FOR_ALL_CONSTRAINTS (c)
printf (",\n CONSTRAINT_%s", c->c_name);
- puts ("\n};\n");
+ puts (",\n CONSTRAINT__LIMIT\n};\n");
}
/* Write out a function which looks at a string and determines what
"}\n");
}
-/* Write out the function which computes constraint name lengths from
- their enumerators. */
+/* Write out a function which looks at a string and determines what
+ the constraint name length is. */
static void
write_insn_constraint_len (void)
{
- struct constraint_data *c;
-
- if (constraint_max_namelen == 1)
- return;
+ unsigned int i;
- puts ("size_t\n"
- "insn_constraint_len (enum constraint_num c)\n"
+ puts ("static inline size_t\n"
+ "insn_constraint_len (char fc, const char *str ATTRIBUTE_UNUSED)\n"
"{\n"
- " switch (c)\n"
+ " switch (fc)\n"
" {");
- FOR_ALL_CONSTRAINTS (c)
- if (c->namelen > 1)
- printf (" case CONSTRAINT_%s: return %lu;\n", c->c_name,
- (unsigned long int) c->namelen);
+ for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++)
+ {
+ struct constraint_data *c = constraints_by_letter_table[i];
+
+ if (!c
+ || c->namelen == 1)
+ continue;
+
+ /* Constraints with multiple characters should have the same
+ length. */
+ {
+ struct constraint_data *c2 = c->next_this_letter;
+ size_t len = c->namelen;
+ while (c2)
+ {
+ if (c2->namelen != len)
+ error ("Multi-letter constraints with first letter '%c' "
+ "should have same length", i);
+ c2 = c2->next_this_letter;
+ }
+ }
+
+ printf (" case '%c': return %lu;\n",
+ i, (unsigned long int) c->namelen);
+ }
puts (" default: break;\n"
" }\n"
" return 1;\n"
"}\n");
}
-
+
/* Write out the function which computes the register class corresponding
to a register constraint. */
static void
/* Write out the functions which compute whether a given value matches
a given non-register constraint. */
static void
-write_satisfies_constraint_fns (void)
+write_tm_constrs_h (void)
{
struct constraint_data *c;
- /* A fair number of places include tm_p.h without including rtl.h. */
- puts ("#ifdef GCC_RTL_H\n");
-
+ printf ("\
+/* Generated automatically by the program '%s'\n\
+ from the machine description file '%s'. */\n\n", progname, in_fname);
+
+ puts ("\
+#ifndef GCC_TM_CONSTRS_H\n\
+#define GCC_TM_CONSTRS_H\n");
+
FOR_ALL_CONSTRAINTS (c)
if (!c->is_register)
{
bool needs_rval = needs_variable (c->exp, "rval");
bool needs_mode = (needs_variable (c->exp, "mode")
|| needs_hval || needs_lval || needs_rval);
+ bool needs_op = (needs_variable (c->exp, "op")
+ || needs_ival || needs_mode);
printf ("static inline bool\n"
- "satisfies_constraint_%s (rtx op)\n"
- "{\n", c->c_name);
+ "satisfies_constraint_%s (rtx %s)\n"
+ "{\n", c->c_name,
+ needs_op ? "op" : "ARG_UNUSED (op)");
if (needs_mode)
- puts ("enum machine_mode mode = GET_MODE (op);");
+ puts (" enum machine_mode mode = GET_MODE (op);");
if (needs_ival)
puts (" HOST_WIDE_INT ival = 0;");
if (needs_hval)
puts (" const REAL_VALUE_TYPE *rval = 0;");
if (needs_ival)
- puts (" if (GET_CODE (op) == CONST_INT)\n"
+ puts (" if (CONST_INT_P (op))\n"
" ival = INTVAL (op);");
if (needs_hval)
puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
if (needs_rval)
puts (" if (GET_CODE (op) == CONST_DOUBLE && mode != VOIDmode)"
" rval = CONST_DOUBLE_REAL_VALUE (op);");
-
- fputs (" return ", stdout);
- write_predicate_expr (c->exp);
- fputs (";\n}\n", stdout);
- }
- puts ("\n#endif /* rtl.h visible */\n");
+ write_predicate_stmts (c->exp);
+ fputs ("}\n", stdout);
+ }
+ puts ("#endif /* tm-constrs.h */");
}
/* Write out the wrapper function, constraint_satisfied_p, that maps
if (c->is_const_int)
{
printf (" case CONSTRAINT_%s:\n return ", c->c_name);
- write_predicate_expr (c->exp);
+ /* c->exp is guaranteed to be (and (match_code "const_int") (...));
+ we know at this point that we have a const_int, so we need not
+ bother with that part of the test. */
+ write_predicate_expr (XEXP (c->exp, 1));
fputs (";\n\n", stdout);
}
"extern bool constraint_satisfied_p (rtx, enum constraint_num);\n");
if (constraint_max_namelen > 1)
- puts ("extern size_t insn_constraint_len (enum constraint_num);\n"
- "#define CONSTRAINT_LEN(c_,s_) "
- "insn_constraint_len (lookup_constraint (s_))\n");
+ {
+ write_insn_constraint_len ();
+ puts ("#define CONSTRAINT_LEN(c_,s_) "
+ "insn_constraint_len (c_,s_)\n");
+ }
else
puts ("#define CONSTRAINT_LEN(c_,s_) 1\n");
if (have_register_constraints)
puts ("extern enum reg_class regclass_for_constraint "
"(enum constraint_num);\n"
"#define REG_CLASS_FROM_CONSTRAINT(c_,s_) \\\n"
- " regclass_for_constraint (lookup_constraint (s_))\n");
+ " regclass_for_constraint (lookup_constraint (s_))\n"
+ "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n"
+ " regclass_for_constraint (x_)\n");
else
- puts ("#define REG_CLASS_FROM_CONSTRAINT(c_,s_) NO_REGS");
+ puts ("#define REG_CLASS_FROM_CONSTRAINT(c_,s_) NO_REGS\n"
+ "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n"
+ " NO_REGS\n");
if (have_const_int_constraints)
puts ("extern bool insn_const_int_ok_for_constraint "
"(HOST_WIDE_INT, enum constraint_num);\n"
"insn_extra_address_constraint (lookup_constraint (s_))\n");
else
puts ("#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) false\n");
-
- if (have_const_int_constraints || have_const_dbl_constraints
- || have_extra_constraints)
- write_satisfies_constraint_fns ();
}
puts ("#endif /* tm-preds.h */");
}
-/* Write insn-preds.c.
+/* Write insn-preds.c.
N.B. the list of headers to include was copied from genrecog; it
may not be ideal.
#include \"function.h\"\n\
#include \"insn-config.h\"\n\
#include \"recog.h\"\n\
-#include \"real.h\"\n\
#include \"output.h\"\n\
#include \"flags.h\"\n\
#include \"hard-reg-set.h\"\n\
#include \"resource.h\"\n\
-#include \"toplev.h\"\n\
+#include \"diagnostic-core.h\"\n\
#include \"reload.h\"\n\
-#include \"regs.h\"\n");
+#include \"regs.h\"\n\
+#include \"tm-constrs.h\"\n");
FOR_ALL_PREDICATES (p)
write_one_predicate_function (p);
if (constraint_max_namelen > 0)
{
write_lookup_constraint ();
- write_regclass_for_constraint ();
+ if (have_register_constraints)
+ write_regclass_for_constraint ();
write_constraint_satisfied_p ();
-
- if (constraint_max_namelen > 1)
- write_insn_constraint_len ();
if (have_const_int_constraints)
write_insn_const_int_ok_for_constraint ();
/* Argument parsing. */
static bool gen_header;
+static bool gen_constrs;
+
static bool
parse_option (const char *opt)
{
gen_header = true;
return 1;
}
+ else if (!strcmp (opt, "-c"))
+ {
+ gen_constrs = true;
+ return 1;
+ }
else
return 0;
}
progname = argv[0];
if (argc <= 1)
fatal ("no input file name");
- if (init_md_reader_args_cb (argc, argv, parse_option) != SUCCESS_EXIT_CODE)
+ if (!init_rtx_reader_args_cb (argc, argv, parse_option))
return FATAL_EXIT_CODE;
while ((defn = read_md_rtx (&pattern_lineno, &next_insn_code)) != 0)
if (gen_header)
write_tm_preds_h ();
+ else if (gen_constrs)
+ write_tm_constrs_h ();
else
write_insn_preds_c ();
OSDN Git Service
