- 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
+ 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"
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;
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 exisiting
+ push this AND down into the second operand of an existing
AND expression. */
if (generate_switch_p (XEXP (subexp, 0)))
pos = &XEXP (subexp, 1);
static void
write_match_code_switch (rtx exp)
{
- const char *codes = (const char *) XEXP (exp, 0);
- const char *path = (const char *) XEXP (exp, 1);
+ const char *codes = XSTR (exp, 0);
+ const char *path = XSTR (exp, 1);
const char *code;
fputs (" switch (GET_CODE (", stdout);
}
}
-/* Given a predictate expression EXP, write out a sequence of stmts
+/* 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. */
" }");
exp = XEXP (exp, 1);
}
+ break;
case NOT:
if (generate_switch_p (XEXP (exp, 0)))
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;
have_error = 1;
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"
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 (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"
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 ();