/* Generate code from to output assembler insns as recognized from rtl.
- Copyright (C) 1987, 1988, 1992, 1994, 1995, 1997, 1998, 1999, 2000
- Free Software Foundation, Inc.
+ Copyright (C) 1987, 1988, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2002,
+ 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
#define MAX_MAX_OPERANDS 40
-static int n_occurrences PARAMS ((int, const char *));
-static const char *strip_whitespace PARAMS ((const char *));
+static int n_occurrences (int, const char *);
+static const char *strip_whitespace (const char *);
/* insns in the machine description are assigned sequential code numbers
that are used by insn-recog.c (produced by genrecog) to communicate
static struct data *idata, **idata_end = &idata;
\f
-static void output_prologue PARAMS ((void));
-static void output_predicate_decls PARAMS ((void));
-static void output_operand_data PARAMS ((void));
-static void output_insn_data PARAMS ((void));
-static void output_get_insn_name PARAMS ((void));
-static void scan_operands PARAMS ((struct data *, rtx, int, int));
-static int compare_operands PARAMS ((struct operand_data *,
- struct operand_data *));
-static void place_operands PARAMS ((struct data *));
-static void process_template PARAMS ((struct data *, const char *));
-static void validate_insn_alternatives PARAMS ((struct data *));
-static void validate_insn_operands PARAMS ((struct data *));
-static void gen_insn PARAMS ((rtx, int));
-static void gen_peephole PARAMS ((rtx, int));
-static void gen_expand PARAMS ((rtx, int));
-static void gen_split PARAMS ((rtx, int));
-static void check_constraint_len PARAMS ((void));
-static int constraint_len PARAMS ((const char *, int));
+static void output_prologue (void);
+static void output_operand_data (void);
+static void output_insn_data (void);
+static void output_get_insn_name (void);
+static void scan_operands (struct data *, rtx, int, int);
+static int compare_operands (struct operand_data *,
+ struct operand_data *);
+static void place_operands (struct data *);
+static void process_template (struct data *, const char *);
+static void validate_insn_alternatives (struct data *);
+static void validate_insn_operands (struct data *);
+static void gen_insn (rtx, int);
+static void gen_peephole (rtx, int);
+static void gen_expand (rtx, int);
+static void gen_split (rtx, int);
+static void check_constraint_len (void);
+static int constraint_len (const char *, int);
\f
const char *
-get_insn_name (index)
- int index;
+get_insn_name (int index)
{
static char buf[100];
}
static void
-output_prologue ()
+output_prologue (void)
{
printf ("/* Generated automatically by the program `genoutput'\n\
from the machine description file `md'. */\n\n");
printf ("#include \"target.h\"\n");
}
-
-/* We need to define all predicates used. Keep a list of those we
- have defined so far. There normally aren't very many predicates
- used, so a linked list should be fast enough. */
-struct predicate { const char *name; struct predicate *next; };
-
static void
-output_predicate_decls ()
-{
- struct predicate *predicates = 0;
- struct operand_data *d;
- struct predicate *p, *next;
-
- for (d = odata; d; d = d->next)
- if (d->predicate && d->predicate[0])
- {
- for (p = predicates; p; p = p->next)
- if (strcmp (p->name, d->predicate) == 0)
- break;
-
- if (p == 0)
- {
- printf ("extern int %s PARAMS ((rtx, enum machine_mode));\n",
- d->predicate);
- p = (struct predicate *) xmalloc (sizeof (struct predicate));
- p->name = d->predicate;
- p->next = predicates;
- predicates = p;
- }
- }
-
- printf ("\n\n");
- for (p = predicates; p; p = next)
- {
- next = p->next;
- free (p);
- }
-}
-
-static void
-output_operand_data ()
+output_operand_data (void)
{
struct operand_data *d;
}
static void
-output_insn_data ()
+output_insn_data (void)
{
struct data *d;
int name_offset = 0;
break;
}
+ printf ("#if GCC_VERSION >= 2007\n__extension__\n#endif\n");
printf ("\nconst struct insn_data insn_data[] = \n{\n");
for (d = idata; d; d = d->next)
switch (d->output_format)
{
case INSN_OUTPUT_FORMAT_NONE:
- printf (" 0,\n");
+ printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
+ printf (" { 0 },\n");
+ printf ("#else\n");
+ printf (" { 0, 0, 0 },\n");
+ printf ("#endif\n");
break;
case INSN_OUTPUT_FORMAT_SINGLE:
{
const char *p = d->template;
char prev = 0;
-
+
+ printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
+ printf (" { .single =\n");
+ printf ("#else\n");
+ printf (" {\n");
+ printf ("#endif\n");
printf (" \"");
while (*p)
{
++p;
}
printf ("\",\n");
+ printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
+ printf (" },\n");
+ printf ("#else\n");
+ printf (" 0, 0 },\n");
+ printf ("#endif\n");
}
break;
case INSN_OUTPUT_FORMAT_MULTI:
+ printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
+ printf (" { .multi = output_%d },\n", d->code_number);
+ printf ("#else\n");
+ printf (" { 0, output_%d, 0 },\n", d->code_number);
+ printf ("#endif\n");
+ break;
case INSN_OUTPUT_FORMAT_FUNCTION:
- printf (" (const PTR) output_%d,\n", d->code_number);
+ printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
+ printf (" { .function = output_%d },\n", d->code_number);
+ printf ("#else\n");
+ printf (" { 0, 0, output_%d },\n", d->code_number);
+ printf ("#endif\n");
break;
default:
abort ();
}
static void
-output_get_insn_name ()
+output_get_insn_name (void)
{
printf ("const char *\n");
- printf ("get_insn_name (code)\n");
- printf (" int code;\n");
+ printf ("get_insn_name (int code)\n");
printf ("{\n");
- printf (" return insn_data[code].name;\n");
+ printf (" if (code == NOOP_MOVE_INSN_CODE)\n");
+ printf (" return \"NOOP_MOVE\";\n");
+ printf (" else\n");
+ printf (" return insn_data[code].name;\n");
printf ("}\n");
}
static int num_dups;
static void
-scan_operands (d, part, this_address_p, this_strict_low)
- struct data *d;
- rtx part;
- int this_address_p;
- int this_strict_low;
+scan_operands (struct data *d, rtx part, int this_address_p,
+ int this_strict_low)
{
int i, j;
const char *format_ptr;
case STRICT_LOW_PART:
scan_operands (d, XEXP (part, 0), 0, 1);
return;
-
+
default:
break;
}
/* Compare two operands for content equality. */
static int
-compare_operands (d0, d1)
- struct operand_data *d0, *d1;
+compare_operands (struct operand_data *d0, struct operand_data *d1)
{
const char *p0, *p1;
find a subsequence that is the same, or allocate a new one at the end. */
static void
-place_operands (d)
- struct data *d;
+place_operands (struct data *d)
{
struct operand_data *od, *od2;
int i;
templates, or C code to generate the assembler code template. */
static void
-process_template (d, template)
- struct data *d;
- const char *template;
+process_template (struct data *d, const char *template)
{
const char *cp;
int i;
d->template = 0;
d->output_format = INSN_OUTPUT_FORMAT_FUNCTION;
- printf ("\nstatic const char *output_%d PARAMS ((rtx *, rtx));\n",
- d->code_number);
puts ("\nstatic const char *");
- printf ("output_%d (operands, insn)\n", d->code_number);
- puts (" rtx *operands ATTRIBUTE_UNUSED;");
- puts (" rtx insn ATTRIBUTE_UNUSED;");
+ printf ("output_%d (rtx *operands ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED)\n",
+ d->code_number);
puts ("{");
puts (template + 1);
for (i = 0, cp = &template[1]; *cp; )
{
+ const char *ep, *sp;
+
while (ISSPACE (*cp))
cp++;
printf (" \"");
- while (!IS_VSPACE (*cp) && *cp != '\0')
+
+ for (ep = sp = cp; !IS_VSPACE (*ep) && *ep != '\0'; ++ep)
+ if (!ISSPACE (*ep))
+ sp = ep + 1;
+
+ if (sp != ep)
+ message_with_line (d->lineno,
+ "trailing whitespace in output template");
+
+ while (cp < sp)
{
putchar (*cp);
cp++;
/* Check insn D for consistency in number of constraint alternatives. */
static void
-validate_insn_alternatives (d)
- struct data *d;
+validate_insn_alternatives (struct data *d)
{
int n = 0, start;
/* Verify that there are no gaps in operand numbers for INSNs. */
static void
-validate_insn_operands (d)
- struct data *d;
+validate_insn_operands (struct data *d)
{
int i;
a hairy output action, output a function for now. */
static void
-gen_insn (insn, lineno)
- rtx insn;
- int lineno;
+gen_insn (rtx insn, int lineno)
{
- struct data *d = (struct data *) xmalloc (sizeof (struct data));
+ struct data *d = xmalloc (sizeof (struct data));
int i;
d->code_number = next_code_number;
If the insn has a hairy output action, output it now. */
static void
-gen_peephole (peep, lineno)
- rtx peep;
- int lineno;
+gen_peephole (rtx peep, int lineno)
{
- struct data *d = (struct data *) xmalloc (sizeof (struct data));
+ struct data *d = xmalloc (sizeof (struct data));
int i;
d->code_number = next_code_number;
only for the purposes of `insn_gen_function'. */
static void
-gen_expand (insn, lineno)
- rtx insn;
- int lineno;
+gen_expand (rtx insn, int lineno)
{
- struct data *d = (struct data *) xmalloc (sizeof (struct data));
+ struct data *d = xmalloc (sizeof (struct data));
int i;
d->code_number = next_code_number;
only for reasons of consistency and to simplify genrecog. */
static void
-gen_split (split, lineno)
- rtx split;
- int lineno;
+gen_split (rtx split, int lineno)
{
- struct data *d = (struct data *) xmalloc (sizeof (struct data));
+ struct data *d = xmalloc (sizeof (struct data));
int i;
d->code_number = next_code_number;
place_operands (d);
}
-extern int main PARAMS ((int, char **));
+extern int main (int, char **);
int
-main (argc, argv)
- int argc;
- char **argv;
+main (int argc, char **argv)
{
rtx desc;
if (GET_CODE (desc) == DEFINE_EXPAND)
gen_expand (desc, line_no);
if (GET_CODE (desc) == DEFINE_SPLIT
- || GET_CODE (desc) == DEFINE_PEEPHOLE2)
+ || GET_CODE (desc) == DEFINE_PEEPHOLE2)
gen_split (desc, line_no);
next_index_number++;
}
printf("\n\n");
- output_predicate_decls ();
output_operand_data ();
output_insn_data ();
output_get_insn_name ();
-1 if S is the null string. */
static int
-n_occurrences (c, s)
- int c;
- const char *s;
+n_occurrences (int c, const char *s)
{
int n = 0;
Return a new string. */
static const char *
-strip_whitespace (s)
- const char *s;
+strip_whitespace (const char *s)
{
char *p, *q;
char ch;
tampered with. This isn't bullet-proof, but it should catch
most genuine mistakes. */
static void
-check_constraint_len ()
+check_constraint_len (void)
{
const char *p;
int d;
}
static int
-constraint_len (p, genoutput_default_constraint_len)
- const char *p;
- int genoutput_default_constraint_len;
+constraint_len (const char *p, int genoutput_default_constraint_len)
{
/* Check that we still match defaults.h . First we do a generation-time
check that fails if the value is not the expected one... */
if (DEFAULT_CONSTRAINT_LEN (*p, p) != 1)
abort ();
- /* And now a comile-time check that should give a diagnostic if the
+ /* And now a compile-time check that should give a diagnostic if the
definition doesn't exactly match. */
#define DEFAULT_CONSTRAINT_LEN(C,STR) 1
/* Now re-define DEFAULT_CONSTRAINT_LEN so that we can verify it is