X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Fgengenrtl.c;h=89d3011796b1cea3ad68197bd00200959d8d9225;hp=54dccf1d0dff2ba3560f44e46ed9294575fb9f6a;hb=a634298771087aa45566135c02aef7751a34dd2a;hpb=791ceafe7e7c0ca0640b64ede4b9cccda4b900e9

diff --git a/gcc/gengenrtl.c b/gcc/gengenrtl.c
index 54dccf1d0df..89d3011796b 100644
--- a/gcc/gengenrtl.c
+++ b/gcc/gengenrtl.c
@@ -1,110 +1,64 @@
 /* Generate code to allocate RTL structures.
-   Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
+   Copyright (C) 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2007
+   Free Software Foundation, Inc.
 
-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 3, 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 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"
-
-/* Calculate the format for CONST_DOUBLE.  This depends on the relative
-   widths of HOST_WIDE_INT and REAL_VALUE_TYPE.
-
-   We need to go out to e0wwwww, since REAL_ARITHMETIC assumes 16-bits
-   per element in REAL_VALUE_TYPE.
-
-   This is duplicated in rtl.c.
-
-   A number of places assume that there are always at least two 'w'
-   slots in a CONST_DOUBLE, so we provide them even if one would suffice.  */
-
-#ifdef REAL_ARITHMETIC
-#if MAX_LONG_DOUBLE_TYPE_SIZE == 96
-#define REAL_WIDTH	(11*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
-#elif MAX_LONG_DOUBLE_TYPE_SIZE == 128
-#define REAL_WIDTH	(19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
-#elif HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
-#define REAL_WIDTH	(7*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
-#endif
-#endif /* REAL_ARITHMETIC */
-
-#ifndef REAL_WIDTH
-#if HOST_BITS_PER_WIDE_INT*2 >= MAX_LONG_DOUBLE_TYPE_SIZE
-#define REAL_WIDTH	2
-#elif HOST_BITS_PER_WIDE_INT*3 >= MAX_LONG_DOUBLE_TYPE_SIZE
-#define REAL_WIDTH	3
-#elif HOST_BITS_PER_WIDE_INT*4 >= MAX_LONG_DOUBLE_TYPE_SIZE
-#define REAL_WIDTH	4
-#endif
-#endif /* REAL_WIDTH */
-
-#if REAL_WIDTH == 1
-#define CONST_DOUBLE_FORMAT	"e0ww"
-#elif REAL_WIDTH == 2
-#define CONST_DOUBLE_FORMAT	"e0ww"
-#elif REAL_WIDTH == 3
-#define CONST_DOUBLE_FORMAT	"e0www"
-#elif REAL_WIDTH == 4
-#define CONST_DOUBLE_FORMAT	"e0wwww"
-#elif REAL_WIDTH == 5
-#define CONST_DOUBLE_FORMAT	"e0wwwww"
-#else
-#define CONST_DOUBLE_FORMAT	/* nothing - will cause syntax error */
-#endif
-
-
-struct rtx_definition 
+struct rtx_definition
 {
-  const char *enumname, *name, *format;
+  const char *const enumname, *const name, *const format;
 };
 
-#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) { STRINGIFY(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 ""
 
-struct rtx_definition defs[] = 
-{  
+#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 */
 };
-
-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 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));
+#define NUM_RTX_CODE ARRAY_SIZE(defs)
+
+static const char *formats[NUM_RTX_CODE];
+
+static const char *type_from_format	(int);
+static const char *accessor_from_format	(int);
+static int special_format		(const char *);
+static int special_rtx			(int);
+static int excluded_rtx			(int);
+static void find_formats		(void);
+static void gendecl			(const char *);
+static void genmacro			(int);
+static void gendef			(const char *);
+static void genlegend			(void);
+static void genheader			(void);
+static void gencode			(void);
 
 /* 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)
     {
@@ -126,16 +80,17 @@ type_from_format (c)
       return "struct bitmap_head_def *";  /* bitmap - typedef not available */
     case 't':
       return "union tree_node *";  /* tree - typedef not available */
+    case 'B':
+      return "struct basic_block_def *";  /* basic block - typedef not available */
     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)
     {
@@ -160,8 +115,11 @@ accessor_from_format (c)
     case 't':
       return "XTREE";
 
+    case 'B':
+      return "XBBDEF";
+
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -169,8 +127,7 @@ accessor_from_format (c)
    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
@@ -178,26 +135,37 @@ special_format (fmt)
 	  || strchr (fmt, 'n') != 0);
 }
 
-/* Return nonzero if the RTL code given by index IDX is one that we should not
-   generate a gen_RTX_FOO function foo (because that function is present
-   elsewhere in the compiler.  */
+/* Return nonzero if the RTL code given by index IDX is one that we should
+   generate a gen_rtx_raw_FOO macro for, not gen_rtx_FOO (because gen_rtx_FOO
+   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
-	  || strcmp (defs[idx].enumname, "CONST_DOUBLE") == 0
 	  || strcmp (defs[idx].enumname, "REG") == 0
-	  || strcmp (defs[idx].enumname, "MEM") == 0);
+	  || strcmp (defs[idx].enumname, "SUBREG") == 0
+	  || strcmp (defs[idx].enumname, "MEM") == 0
+	  || strcmp (defs[idx].enumname, "CONST_VECTOR") == 0);
+}
+
+/* Return nonzero if the RTL code given by index IDX is one that we should
+   generate no macro for at all (because gen_rtx_FOO is never used or
+   cannot have the obvious interface).  */
+
+static int
+excluded_rtx (int idx)
+{
+  return ((strcmp (defs[idx].enumname, "CONST_DOUBLE") == 0)
+	  || (strcmp (defs[idx].enumname, "CONST_FIXED") == 0));
 }
 
-/* Place a list of all format specifiers we use into the array FORMAT. */
+/* 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++)
     {
@@ -218,13 +186,12 @@ find_formats ()
 /* Write the declarations for the routine to allocate RTL with FORMAT.  */
 
 static void
-gendecl (format)
-     const char *format;
+gendecl (const char *format)
 {
   const char *p;
   int i, pos;
-  
-  printf ("extern rtx gen_rtx_fmt_%s\tPARAMS ((RTX_CODE, ", format);
+
+  printf ("extern rtx gen_rtx_fmt_%s_stat\t (RTX_CODE, ", format);
   printf ("enum machine_mode mode");
 
   /* Write each parameter that is needed and start a new line when the line
@@ -241,16 +208,25 @@ gendecl (format)
 	printf (" %sarg%d", type_from_format (*p), i++);
 	pos += ourlen;
       }
+  printf (" MEM_STAT_DECL");
 
-  printf ("));\n");
+  printf (");\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 macros to generate RTL of code IDX using the functions we
    write.  */
 
-static void 
-genmacro (idx)
-     int idx;
+static void
+genmacro (int idx)
 {
   const char *p;
   int i;
@@ -258,6 +234,10 @@ genmacro (idx)
   /* We write a macro that defines gen_rtx_RTLCODE to be an equivalent to
      gen_rtx_fmt_FORMAT where FORMAT is the RTX_FORMAT of RTLCODE.  */
 
+  if (excluded_rtx (idx))
+    /* Don't define a macro for this code.  */
+    return;
+
   printf ("#define gen_rtx_%s%s(MODE",
 	   special_rtx (idx) ? "raw_" : "", defs[idx].enumname);
 
@@ -279,36 +259,27 @@ genmacro (idx)
    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 ("rtx\ngen_rtx_fmt_%s_stat (RTX_CODE code, enum 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;");
-  puts ("  if (ggc_p)");
-  printf ("    rt = ggc_alloc_rtx (%d);\n", (int) strlen (format));
-  puts ("  else");
-  printf ("    rt = obstack_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);");
 
   for (p = format, i = j = 0; *p ; ++p, ++i)
@@ -323,7 +294,7 @@ gendef (format)
 /* Generate the documentation header for files we write.  */
 
 static void
-genlegend ()
+genlegend (void)
 {
   puts ("/* Generated automatically by gengenrtl from rtl.def.  */\n");
 }
@@ -331,11 +302,15 @@ genlegend ()
 /* 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);
 
@@ -344,57 +319,35 @@ genheader ()
   for (i = 0; i < NUM_RTX_CODE; i++)
     if (! special_format (defs[i].format))
       genmacro (i);
+
+  puts ("\n#endif /* GCC_GENRTL_H */");
 }
 
 /* Generate the text of the code file we write, genrtl.c.  */
 
 static void
-gencode ()
+gencode (void)
 {
   const char **fmt;
 
   puts ("#include \"config.h\"");
   puts ("#include \"system.h\"");
+  puts ("#include \"coretypes.h\"");
+  puts ("#include \"tm.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) - 2) * sizeof (rtunion)))\n");
 
   for (fmt = formats; *fmt != 0; fmt++)
     gendef (*fmt);
 }
 
-#if defined(USE_C_ALLOCA)
-PTR
-xmalloc (nbytes)
-  size_t nbytes;
-{
-  register PTR tmp = (PTR) malloc (nbytes);
-
-  if (!tmp)
-    {
-      fprintf (stderr, "can't allocate %d bytes (out of virtual memory)\n",
-	       nbytes);
-      exit (FATAL_EXIT_CODE);
-    }
-
-  return tmp;
-}
-#endif /* USE_C_ALLOCA */
-
 /* 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 **));
 
 int
-main (argc, argv)
-     int argc;
-     char **argv;
+main (int argc, char **argv)
 {
   find_formats ();
   genlegend ();
@@ -404,6 +357,8 @@ main (argc, argv)
   else
     gencode ();
 
-  fflush (stdout);
-  return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
+  if (ferror (stdout) || fflush (stdout) || fclose (stdout))
+    return FATAL_EXIT_CODE;
+
+  return SUCCESS_EXIT_CODE;
 }