/* Generate code to allocate RTL structures.
- Copyright (C) 1997, 1998, 1999, 2000, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1997-2015 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) any later
+Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
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, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
-#include "hconfig.h"
+#include "bconfig.h"
#include "system.h"
-#define NO_GENRTL_H
-#include "rtl.h"
-#undef abort
-
-#include "real.h"
-
struct rtx_definition
{
const char *const enumname, *const name, *const format;
};
-#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) { STRINGX(ENUM), NAME, FORMAT },
+/* rtl.def needs CONST_DOUBLE_FORMAT, but we don't care what
+ CONST_DOUBLE_FORMAT is because we're not going to be generating
+ anything for CONST_DOUBLE anyway. */
+#define CONST_DOUBLE_FORMAT ""
+
+#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) { #ENUM, NAME, FORMAT },
static const struct rtx_definition defs[] =
{
#include "rtl.def" /* rtl expressions are documented here */
};
+#define NUM_RTX_CODE ARRAY_SIZE (defs)
static const char *formats[NUM_RTX_CODE];
-
-static const char *type_from_format PARAMS ((int));
-static const char *accessor_from_format PARAMS ((int));
-static int special_format PARAMS ((const char *));
-static int special_rtx PARAMS ((int));
-static int excluded_rtx PARAMS ((int));
-static void find_formats PARAMS ((void));
-static void gendecl PARAMS ((const char *));
-static void genmacro PARAMS ((int));
-static void gendef PARAMS ((const char *));
-static void genlegend PARAMS ((void));
-static void genheader PARAMS ((void));
-static void gencode PARAMS ((void));
\f
/* Decode a format letter into a C type string. */
static const char *
-type_from_format (c)
- int c;
+type_from_format (int c)
{
switch (c)
{
case 'E':
return "rtvec ";
- case 'b':
- return "struct bitmap_head_def *"; /* bitmap - typedef not available */
case 't':
- return "union tree_node *"; /* tree - typedef not available */
+ return "tree ";
+ case 'B':
+ return "basic_block ";
default:
- abort ();
+ gcc_unreachable ();
}
}
/* Decode a format letter into the proper accessor function. */
static const char *
-accessor_from_format (c)
- int c;
+accessor_from_format (int c)
{
switch (c)
{
case 'E':
return "XVEC";
- case 'b':
- return "XBITMAP";
-
case 't':
return "XTREE";
+ case 'B':
+ return "XBBDEF";
+
default:
- abort ();
+ gcc_unreachable ();
}
}
the list of formats we write routines to create. */
static int
-special_format (fmt)
- const char *fmt;
+special_format (const char *fmt)
{
return (strchr (fmt, '*') != 0
|| strchr (fmt, 'V') != 0
|| strchr (fmt, 'S') != 0
- || strchr (fmt, 'n') != 0);
+ || strchr (fmt, 'n') != 0
+ || strchr (fmt, 'r') != 0);
+}
+
+/* Return true if CODE always has VOIDmode. */
+
+static inline bool
+always_void_p (int idx)
+{
+ return strcmp (defs[idx].enumname, "SET") == 0;
}
/* Return nonzero if the RTL code given by index IDX is one that we should
is a wrapper in emit-rtl.c). */
static int
-special_rtx (idx)
- int idx;
+special_rtx (int idx)
{
- return (strcmp (defs[idx].enumname, "CONST_INT") == 0
+ return (strcmp (defs[idx].enumname, "EXPR_LIST") == 0
+ || strcmp (defs[idx].enumname, "INSN_LIST") == 0
+ || strcmp (defs[idx].enumname, "INSN") == 0
+ || strcmp (defs[idx].enumname, "CONST_INT") == 0
|| strcmp (defs[idx].enumname, "REG") == 0
|| strcmp (defs[idx].enumname, "SUBREG") == 0
- || strcmp (defs[idx].enumname, "MEM") == 0);
+ || strcmp (defs[idx].enumname, "MEM") == 0
+ || strcmp (defs[idx].enumname, "PC") == 0
+ || strcmp (defs[idx].enumname, "CC0") == 0
+ || strcmp (defs[idx].enumname, "RETURN") == 0
+ || strcmp (defs[idx].enumname, "SIMPLE_RETURN") == 0
+ || strcmp (defs[idx].enumname, "CONST_VECTOR") == 0);
}
/* Return nonzero if the RTL code given by index IDX is one that we should
cannot have the obvious interface). */
static int
-excluded_rtx (idx)
- int idx;
+excluded_rtx (int idx)
{
- return (strcmp (defs[idx].enumname, "CONST_DOUBLE") == 0);
+ return (strcmp (defs[idx].enumname, "VAR_LOCATION") == 0
+ || strcmp (defs[idx].enumname, "CONST_DOUBLE") == 0
+ || strcmp (defs[idx].enumname, "CONST_WIDE_INT") == 0
+ || strcmp (defs[idx].enumname, "CONST_FIXED") == 0);
}
/* Place a list of all format specifiers we use into the array FORMAT. */
static void
-find_formats ()
+find_formats (void)
{
- int i;
+ unsigned int i;
for (i = 0; i < NUM_RTX_CODE; i++)
{
}
}
-/* Write the declarations for the routine to allocate RTL with FORMAT. */
-
-static void
-gendecl (format)
- const char *format;
-{
- const char *p;
- int i, pos;
-
- printf ("extern rtx gen_rtx_fmt_%s\tPARAMS ((RTX_CODE, ", format);
- printf ("enum machine_mode mode");
-
- /* Write each parameter that is needed and start a new line when the line
- would overflow. */
- for (p = format, i = 0, pos = 75; *p != 0; p++)
- if (*p != '0')
- {
- int ourlen = strlen (type_from_format (*p)) + 6 + (i > 9);
-
- printf (",");
- if (pos + ourlen > 76)
- printf ("\n\t\t\t\t "), pos = 39;
-
- printf (" %sarg%d", type_from_format (*p), i++);
- pos += ourlen;
- }
-
- printf ("));\n");
-}
/* Generate macros to generate RTL of code IDX using the functions we
write. */
static void
-genmacro (idx)
- int idx;
+genmacro (int idx)
{
const char *p;
+ const char *sep = "";
int i;
/* We write a macro that defines gen_rtx_RTLCODE to be an equivalent to
/* Don't define a macro for this code. */
return;
- printf ("#define gen_rtx_%s%s(MODE",
+ bool has_mode_p = !always_void_p (idx);
+ printf ("#define gen_rtx_%s%s(",
special_rtx (idx) ? "raw_" : "", defs[idx].enumname);
+ if (has_mode_p)
+ {
+ printf ("MODE");
+ sep = ", ";
+ }
for (p = defs[idx].format, i = 0; *p != 0; p++)
if (*p != '0')
- printf (", ARG%d", i++);
+ {
+ printf ("%sARG%d", sep, i++);
+ sep = ", ";
+ }
- printf (") \\\n gen_rtx_fmt_%s (%s, (MODE)",
- defs[idx].format, defs[idx].enumname);
+ printf (") \\\n gen_rtx_fmt_%s (%s, %s",
+ defs[idx].format, defs[idx].enumname,
+ has_mode_p ? "(MODE)" : "VOIDmode");
for (p = defs[idx].format, i = 0; *p != 0; p++)
if (*p != '0')
format is FORMAT. */
static void
-gendef (format)
- const char *format;
+gendef (const char *format)
{
const char *p;
int i, j;
/* Start by writing the definition of the function name and the types
of the arguments. */
- printf ("rtx\ngen_rtx_fmt_%s (code, mode", format);
+ printf ("static inline rtx\ngen_rtx_fmt_%s_stat (RTX_CODE code, machine_mode mode", format);
for (p = format, i = 0; *p != 0; p++)
if (*p != '0')
- printf (", arg%d", i++);
+ printf (",\n\t%sarg%d", type_from_format (*p), i++);
- puts (")\n RTX_CODE code;\n enum machine_mode mode;");
- for (p = format, i = 0; *p != 0; p++)
- if (*p != '0')
- printf (" %sarg%d;\n", type_from_format (*p), i++);
+ puts (" MEM_STAT_DECL)");
/* Now write out the body of the function itself, which allocates
the memory and initializes it. */
puts ("{");
puts (" rtx rt;");
- printf (" rt = ggc_alloc_rtx (%d);\n", (int) strlen (format));
+ puts (" rt = rtx_alloc_stat (code PASS_MEM_STAT);\n");
- puts (" memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));\n");
- puts (" PUT_CODE (rt, code);");
- puts (" PUT_MODE (rt, mode);");
+ puts (" PUT_MODE_RAW (rt, mode);");
for (p = format, i = j = 0; *p ; ++p, ++i)
if (*p != '0')
printf (" X0EXP (rt, %d) = NULL_RTX;\n", i);
puts ("\n return rt;\n}\n");
+ printf ("#define gen_rtx_fmt_%s(c, m", format);
+ for (p = format, i = 0; *p != 0; p++)
+ if (*p != '0')
+ printf (", p%i",i++);
+ printf (")\\\n gen_rtx_fmt_%s_stat (c, m", format);
+ for (p = format, i = 0; *p != 0; p++)
+ if (*p != '0')
+ printf (", p%i",i++);
+ printf (" MEM_STAT_INFO)\n\n");
}
/* Generate the documentation header for files we write. */
static void
-genlegend ()
+genlegend (void)
{
puts ("/* Generated automatically by gengenrtl from rtl.def. */\n");
}
/* Generate the text of the header file we make, genrtl.h. */
static void
-genheader ()
+genheader (void)
{
- int i;
+ unsigned int i;
const char **fmt;
puts ("#ifndef GCC_GENRTL_H");
puts ("#define GCC_GENRTL_H\n");
+ puts ("#include \"statistics.h\"\n");
for (fmt = formats; *fmt; ++fmt)
- gendecl (*fmt);
+ gendef (*fmt);
putchar ('\n');
puts ("\n#endif /* GCC_GENRTL_H */");
}
-/* Generate the text of the code file we write, genrtl.c. */
-
-static void
-gencode ()
-{
- const char **fmt;
-
- puts ("#include \"config.h\"");
- puts ("#include \"system.h\"");
- puts ("#include \"obstack.h\"");
- puts ("#include \"rtl.h\"");
- puts ("#include \"ggc.h\"\n");
- puts ("extern struct obstack *rtl_obstack;\n");
- puts ("#define obstack_alloc_rtx(n) \\");
- puts (" ((rtx) obstack_alloc (rtl_obstack, \\");
- puts (" sizeof (struct rtx_def) \\");
- puts (" + ((n) - 1) * sizeof (rtunion)))\n");
-
- for (fmt = formats; *fmt != 0; fmt++)
- gendef (*fmt);
-}
-
-/* This is the main program. We accept only one argument, "-h", which
- says we are writing the genrtl.h file. Otherwise we are writing the
- genrtl.c file. */
-extern int main PARAMS ((int, char **));
+/* This is the main program. */
int
-main (argc, argv)
- int argc;
- char **argv;
+main (void)
{
find_formats ();
genlegend ();
- if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'h')
- genheader ();
- else
- gencode ();
+ genheader ();
if (ferror (stdout) || fflush (stdout) || fclose (stdout))
return FATAL_EXIT_CODE;