Imported gcc-4.4.3

[msp430-gcc.git] / gcc / gengenrtl.c

diff --git a/gcc/gengenrtl.c b/gcc/gengenrtl.c
index 157baf179e026ae3c81f00cecc6b9798dde46bbb..89d3011796b1cea3ad68197bd00200959d8d9225 100644 (file)
--- a/gcc/gengenrtl.c
+++ b/gcc/gengenrtl.c
@@ -1,11 +1,12 @@
 /* Generate code to allocate RTL structures.
 /* 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 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
 
 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
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY


@@ -14,116 +15,50 @@ 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
 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"
 
 #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
-# else
-#  if MAX_LONG_DOUBLE_TYPE_SIZE == 128
-#   define REAL_WIDTH  \
-      (19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
-#  else
-#   if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
-#    define REAL_WIDTH \
-      (7*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
-#   endif
-#  endif
-# endif
-#endif /* REAL_ARITHMETIC */
-
-#ifndef REAL_WIDTH
-# if HOST_BITS_PER_WIDE_INT*2 >= MAX_LONG_DOUBLE_TYPE_SIZE
-#  define REAL_WIDTH   2
-# else
-#  if HOST_BITS_PER_WIDE_INT*3 >= MAX_LONG_DOUBLE_TYPE_SIZE
-#   define REAL_WIDTH  3
-#  else
-#   if HOST_BITS_PER_WIDE_INT*4 >= MAX_LONG_DOUBLE_TYPE_SIZE
-#    define REAL_WIDTH 4
-#   endif
-#  endif
-# endif
-#endif /* REAL_WIDTH */
-
-#if REAL_WIDTH == 1
-# define CONST_DOUBLE_FORMAT   "0ww"
-#else
-# if REAL_WIDTH == 2
-#  define CONST_DOUBLE_FORMAT  "0ww"
-# else
-#  if REAL_WIDTH == 3
-#   define CONST_DOUBLE_FORMAT "0www"
-#  else
-#   if REAL_WIDTH == 4
-#    define CONST_DOUBLE_FORMAT        "0wwww"
-#   else
-#    if REAL_WIDTH == 5
-#     define CONST_DOUBLE_FORMAT       "0wwwww"
-#    else
-#     define CONST_DOUBLE_FORMAT /* nothing - will cause syntax error */
-#    endif
-#   endif
-#  endif
-# endif
-#endif
-
-
-struct rtx_definition 
+struct rtx_definition

 {
   const char *const enumname, *const name, *const format;
 };
 
 {
   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 ""

 
 

-static const 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 */
 };
 #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 *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));
+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);

 \f
 /* Decode a format letter into a C type string.  */
 
 static const char *
 \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)
     {
 {
   switch (c)
     {


@@ -145,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 */
       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:
     default:

-      abort ();
+      gcc_unreachable ();

     }
 }
 
 /* Decode a format letter into the proper accessor function.  */
 
 static const char *
     }
 }
 
 /* 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)
     {
 {
   switch (c)
     {


@@ -179,8 +115,11 @@ accessor_from_format (c)
     case 't':
       return "XTREE";
 
     case 't':
       return "XTREE";
 

+    case 'B':
+      return "XBBDEF";
+

     default:
     default:

-      abort ();
+      gcc_unreachable ();

     }
 }
 
     }
 }
 


@@ -188,8 +127,7 @@ accessor_from_format (c)
    the list of formats we write routines to create.  */
 
 static int
    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
 {
   return (strchr (fmt, '*') != 0
          || strchr (fmt, 'V') != 0


@@ -197,27 +135,37 @@ special_format (fmt)
          || strchr (fmt, 'n') != 0);
 }
 
          || 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
 
 static int

-special_rtx (idx)
-     int idx;
+special_rtx (int idx)

 {
   return (strcmp (defs[idx].enumname, "CONST_INT") == 0
 {
   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, "SUBREG") == 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, "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.  */
 
 static void
 }
 
 /* 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++)
     {
 
   for (i = 0; i < NUM_RTX_CODE; i++)
     {


@@ -238,13 +186,12 @@ find_formats ()
 /* Write the declarations for the routine to allocate RTL with FORMAT.  */
 
 static void
 /* 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;
 {
   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
   printf ("enum machine_mode mode");
 
   /* Write each parameter that is needed and start a new line when the line


@@ -261,16 +208,25 @@ gendecl (format)
        printf (" %sarg%d", type_from_format (*p), i++);
        pos += ourlen;
       }
        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.  */
 
 }
 
 /* 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;
 {
   const char *p;
   int i;


@@ -278,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.  */
 
   /* 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);
 
   printf ("#define gen_rtx_%s%s(MODE",
           special_rtx (idx) ? "raw_" : "", defs[idx].enumname);
 


@@ -299,33 +259,27 @@ genmacro (idx)
    format is FORMAT.  */
 
 static void
    format is FORMAT.  */
 
 static void

-gendef (format)
-     const char *format;
+gendef (const char *format)

 {
   const char *p;
   int i, j;
 {
   const char *p;
   int i, j;

-  
+

   /* Start by writing the definition of the function name and the types
      of the arguments.  */
 
   /* 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')
   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;");
 
   /* 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);");
 
   for (p = format, i = j = 0; *p ; ++p, ++i)
   puts ("  PUT_MODE (rt, mode);");
 
   for (p = format, i = j = 0; *p ; ++p, ++i)


@@ -340,7 +294,7 @@ gendef (format)
 /* Generate the documentation header for files we write.  */
 
 static void
 /* Generate the documentation header for files we write.  */
 
 static void

-genlegend ()
+genlegend (void)

 {
   puts ("/* Generated automatically by gengenrtl from rtl.def.  */\n");
 }
 {
   puts ("/* Generated automatically by gengenrtl from rtl.def.  */\n");
 }


@@ -348,13 +302,14 @@ genlegend ()
 /* Generate the text of the header file we make, genrtl.h.  */
 
 static void
 /* 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");
   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);
 
   for (fmt = formats; *fmt; ++fmt)
     gendecl (*fmt);


@@ -371,20 +326,17 @@ genheader ()
 /* Generate the text of the code file we write, genrtl.c.  */
 
 static void
 /* 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\"");
 {
   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 ("#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);
 
   for (fmt = formats; *fmt != 0; fmt++)
     gendef (*fmt);


@@ -393,12 +345,9 @@ gencode ()
 /* 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.  */
 /* 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
 
 int

-main (argc, argv)
-     int argc;
-     char **argv;
+main (int argc, char **argv)

 {
   find_formats ();
   genlegend ();
 {
   find_formats ();
   genlegend ();