1999, 2000 Free Software Foundation, Inc.
Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
-This file is part of GNU CC.
+This file is part of GCC.
-GNU CC 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)
-any later version.
+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) any later
+version.
-GNU CC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+along with GCC; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
/* This program handles insn attributes and the DEFINE_DELAY and
DEFINE_FUNCTION_UNIT definitions.
static void attr_hash_add_rtx PARAMS ((int, rtx));
static void attr_hash_add_string PARAMS ((int, char *));
static rtx attr_rtx PARAMS ((enum rtx_code, ...));
-static char *attr_printf PARAMS ((int, const char *, ...))
+static char *attr_printf PARAMS ((unsigned int, const char *, ...))
ATTRIBUTE_PRINTF_2;
static char *attr_string PARAMS ((const char *, int));
static rtx check_attr_test PARAMS ((rtx, int, int));
int hashcode;
rtx rtl;
{
- register struct attr_hash *h;
+ struct attr_hash *h;
h = (struct attr_hash *) obstack_alloc (hash_obstack,
sizeof (struct attr_hash));
int hashcode;
char *str;
{
- register struct attr_hash *h;
+ struct attr_hash *h;
h = (struct attr_hash *) obstack_alloc (hash_obstack,
sizeof (struct attr_hash));
enum rtx_code code;
#endif
va_list p;
- register int i; /* Array indices... */
- register const char *fmt; /* Current rtx's format... */
- register rtx rt_val = NULL_RTX;/* RTX to return to caller... */
+ int i; /* Array indices... */
+ const char *fmt; /* Current rtx's format... */
+ rtx rt_val = NULL_RTX;/* RTX to return to caller... */
int hashcode;
- register struct attr_hash *h;
+ struct attr_hash *h;
struct obstack *old_obstack = rtl_obstack;
VA_START (p, code);
rtx attr_printf (len, format, [arg1, ..., argn]) */
static char *
-attr_printf VPARAMS ((register int len, const char *fmt, ...))
+attr_printf VPARAMS ((unsigned int len, const char *fmt, ...))
{
-#ifndef ANSI_PROTOTYPES
- register int len;
- const char *fmt;
-#endif
- va_list p;
char str[256];
- VA_START (p, fmt);
-
-#ifndef ANSI_PROTOTYPES
- len = va_arg (p, int);
- fmt = va_arg (p, const char *);
-#endif
-
- if (len > 255) /* leave room for \0 */
+ VA_OPEN (p, fmt);
+ VA_FIXEDARG (p, unsigned int, len);
+ VA_FIXEDARG (p, const char *, fmt);
+
+ if (len > sizeof str - 1) /* Leave room for \0. */
abort ();
vsprintf (str, fmt, p);
- va_end (p);
+ VA_CLOSE (p);
return attr_string (str, strlen (str));
}
const char *str;
int len;
{
- register struct attr_hash *h;
+ struct attr_hash *h;
int hashcode;
int i;
- register char *new_str;
+ char *new_str;
/* Compute the hash code. */
hashcode = (len + 1) * 613 + (unsigned) str[0];
static rtx
attr_copy_rtx (orig)
- register rtx orig;
+ rtx orig;
{
- register rtx copy;
- register int i, j;
- register RTX_CODE code;
- register const char *format_ptr;
+ rtx copy;
+ int i, j;
+ RTX_CODE code;
+ const char *format_ptr;
/* No need to copy a permanent object. */
if (RTX_INTEGRATED_P (orig))
in the attribute (or `alternative_name') to speed up subsequent
`find_attr' calls and eliminate most `strcmp' calls.
- Return the new expression, if any. */
+ Return the new expression, if any. */
static rtx
check_attr_test (exp, is_const, lineno)
if (attr->is_numeric)
{
for (p = XSTR (exp, 1); *p; p++)
- if (*p < '0' || *p > '9')
+ if (! ISDIGIT (*p))
fatal ("Attribute `%s' takes only numeric values",
XSTR (exp, 0));
}
if (attr && attr->negative_ok && *p == '-')
p++;
for (; *p; p++)
- if (*p > '9' || *p < '0')
+ if (! ISDIGIT (*p))
{
message_with_line (attr ? attr->lineno : 0,
"non-numeric value for numeric attribute %s",
newexp = attr_rtx (IF_THEN_ELSE, condexp,
make_numeric_value (1), make_numeric_value (0));
- p = attr_printf (sizeof ("*delay__") + MAX_DIGITS * 2,
- "*delay_%d_%d",
- delay->num, i / 3);
+ p = attr_printf (sizeof "*delay__" + MAX_DIGITS * 2,
+ "*delay_%d_%d", delay->num, i / 3);
make_internal_attr (p, newexp, 1);
if (have_annul_true)
newexp = attr_rtx (IF_THEN_ELSE, condexp,
make_numeric_value (1),
make_numeric_value (0));
- p = attr_printf (sizeof ("*annul_true__") + MAX_DIGITS * 2,
+ p = attr_printf (sizeof "*annul_true__" + MAX_DIGITS * 2,
"*annul_true_%d_%d", delay->num, i / 3);
make_internal_attr (p, newexp, 1);
}
newexp = attr_rtx (IF_THEN_ELSE, condexp,
make_numeric_value (1),
make_numeric_value (0));
- p = attr_printf (sizeof ("*annul_false__") + MAX_DIGITS * 2,
+ p = attr_printf (sizeof "*annul_false__" + MAX_DIGITS * 2,
"*annul_false_%d_%d", delay->num, i / 3);
make_internal_attr (p, newexp, 1);
}
!= unit->issue_delay.max);
if (unit->needs_conflict_function)
{
- str = attr_printf (strlen (unit->name) + sizeof ("*_cost_") + MAX_DIGITS,
+ str = attr_printf ((strlen (unit->name) + sizeof "*_cost_"
+ + MAX_DIGITS),
"*%s_cost_%d", unit->name, op->num);
make_internal_attr (str, issue_exp, 1);
}
}
/* Make an attribute for use in the blockage function. */
- str = attr_printf (strlen (unit->name) + sizeof ("*_block_") + MAX_DIGITS,
+ str = attr_printf ((strlen (unit->name) + sizeof "*_block_"
+ + MAX_DIGITS),
"*%s_block_%d", unit->name, op->num);
make_internal_attr (str, blockage, 1);
}
newexp = operate_exp (RANGE_OP, min_blockage, max_blockage);
newexp = simplify_knowing (newexp, unit->condexp);
- str = attr_printf (strlen (unit->name) + sizeof ("*_unit_blockage_range"),
+ str = attr_printf ((strlen (unit->name)
+ + sizeof "*_unit_blockage_range"),
"*%s_unit_blockage_range", unit->name);
make_internal_attr (str, newexp, 20);
}
- str = attr_printf (strlen (unit->name) + sizeof ("*_unit_ready_cost"),
+ str = attr_printf (strlen (unit->name) + sizeof "*_unit_ready_cost",
"*%s_unit_ready_cost", unit->name);
}
else
}
/* Simplifying caseexp with simplify_by_exploding doesn't win. */
- str = attr_printf (strlen (unit->name) + sizeof ("*_cases"),
+ str = attr_printf (strlen (unit->name) + sizeof "*_cases",
"*%s_cases", unit->name);
make_internal_attr (str, caseexp, 1);
}
encode_units_mask (x)
rtx x;
{
- register int i;
- register int j;
- register enum rtx_code code;
- register const char *fmt;
+ int i;
+ int j;
+ enum rtx_code code;
+ const char *fmt;
code = GET_CODE (x);
static void
make_length_attrs ()
{
- static const char *new_names[] = {"*insn_default_length",
+ static const char *const new_names[] = {"*insn_default_length",
"*insn_variable_length_p",
"*insn_current_length"};
- static rtx (*no_address_fn[]) PARAMS ((rtx)) = {identity_fn, zero_fn, zero_fn};
- static rtx (*address_fn[]) PARAMS ((rtx)) = {max_fn, one_fn, identity_fn};
+ static rtx (*const no_address_fn[]) PARAMS ((rtx)) = {identity_fn, zero_fn, zero_fn};
+ static rtx (*const address_fn[]) PARAMS ((rtx)) = {max_fn, one_fn, identity_fn};
size_t i;
struct attr_desc *length_attr, *new_attr;
struct attr_value *av, *new_av;
return exp;
}
/* Compute approximate cost of the expression. Used to decide whether
- expression is cheap enought for inline. */
+ expression is cheap enough for inline. */
static int
attr_rtx_cost (x)
rtx x;
/* Look at the value for this insn code in the specified attribute.
We normally can replace this comparison with the condition that
- would give this insn the values being tested for. */
+ would give this insn the values being tested for. */
if (XSTR (exp, 0) != alternative_name
&& (attr = find_attr (XSTR (exp, 0), 0)) != NULL)
for (av = attr->first_value; av; av = av->next)
simplify_with_current_value_aux (exp)
rtx exp;
{
- register int i;
+ int i;
rtx cond;
switch (GET_CODE (exp))
clear_struct_flag (x)
rtx x;
{
- register int i;
- register int j;
- register enum rtx_code code;
- register const char *fmt;
+ int i;
+ int j;
+ enum rtx_code code;
+ const char *fmt;
MEM_IN_STRUCT_P (x) = 0;
if (RTX_UNCHANGING_P (x))
rtx x;
int max;
{
- register int i;
- register int j;
- register enum rtx_code code;
- register const char *fmt;
+ int i;
+ int j;
+ enum rtx_code code;
+ const char *fmt;
int total = 0;
code = GET_CODE (x);
walk_attr_value (exp)
rtx exp;
{
- register int i, j;
- register const char *fmt;
+ int i, j;
+ const char *fmt;
RTX_CODE code;
if (exp == NULL)
return 0;
if (!attr->is_numeric)
- printf (" register enum attr_%s ", attr->name);
+ printf (" enum attr_%s ", attr->name);
else if (attr->unsigned_p)
- printf (" register unsigned int ");
+ printf (" unsigned int ");
else
- printf (" register int ");
+ printf (" int ");
printf ("attr_%s = get_attr_%s (insn);\n", attr->name, attr->name);
return 1;
if (!attr->is_const)
write_expr_attr_cache (p, attr);
- printf (" register unsigned long accum = 0;\n\n");
+ printf (" unsigned long accum = 0;\n\n");
while (GET_CODE (p) == IOR)
{
printf ("int\n");
printf ("eligible_for_%s (delay_insn, slot, candidate_insn, flags)\n",
kind);
- printf (" rtx delay_insn;\n");
+ printf (" rtx delay_insn ATTRIBUTE_UNUSED;\n");
printf (" int slot;\n");
printf (" rtx candidate_insn;\n");
printf (" int flags ATTRIBUTE_UNUSED;\n");
the function units. The name is included for documentation purposes
only. */
- printf ("struct function_unit_desc function_units[] = {\n");
+ printf ("const struct function_unit_desc function_units[] = {\n");
/* Write out the descriptions in numeric order, but don't force that order
on the list. Doing so increases the runtime of genattrtab.c. */
static rtx
copy_rtx_unchanging (orig)
- register rtx orig;
+ rtx orig;
{
#if 0
- register rtx copy;
- register RTX_CODE code;
+ rtx copy;
+ RTX_CODE code;
#endif
if (RTX_UNCHANGING_P (orig) || MEM_IN_STRUCT_P (orig))
if (argc <= 1)
fatal ("No input file name.");
- if (init_md_reader (argv[1]) != SUCCESS_EXIT_CODE)
+ if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
return (FATAL_EXIT_CODE);
obstack_init (hash_obstack);
OSDN Git Service
