OSDN Git Service

(root) / pf3gnuchains / gcc-fork.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* gcc.target/i386/builtin-apply-mmx.c: Do not XFAIL on Darwin.
[pf3gnuchains/gcc-fork.git] / gcc / print-tree.c
diff --git a/gcc/print-tree.c b/gcc/print-tree.c
index f5c7d88..7df8161 100644 (file)
--- a/gcc/print-tree.c
+++ b/gcc/print-tree.c
@@ -1,12 +1,12 @@
-/* Prints out tree in human readable form - GNU C-compiler
+/* Prints out tree in human readable form - GCC
    Copyright (C) 1990, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
    Copyright (C) 1990, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-   2001, 2002 Free Software Foundation, Inc.
+   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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
@@ -15,16 +15,20 @@ 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 "config.h"
 #include "system.h"
 
 
 #include "config.h"
 #include "system.h"
+#include "coretypes.h"
+#include "tm.h"
 #include "tree.h"
 #include "tree.h"
+#include "real.h"
+#include "fixed-value.h"
 #include "ggc.h"
 #include "langhooks.h"
 #include "ggc.h"
 #include "langhooks.h"
+#include "tree-iterator.h"
 
 /* Define the hash table of nodes already seen.
    Such nodes are not repeated; brief cross-references are used.  */
 
 /* Define the hash table of nodes already seen.
    Such nodes are not repeated; brief cross-references are used.  */
@@ -44,26 +48,31 @@ static struct bucket **table;
    down to a depth of six.  */
 
 void
    down to a depth of six.  */
 
 void
-debug_tree (node)
-     tree node;
+debug_tree (tree node)
 {
 {
-  table = (struct bucket **) permalloc (HASH_SIZE * sizeof (struct bucket *));
-  memset ((char *) table, 0, HASH_SIZE * sizeof (struct bucket *));
+  table = XCNEWVEC (struct bucket *, HASH_SIZE);
   print_node (stderr, "", node, 0);
   print_node (stderr, "", node, 0);
+  free (table);
   table = 0;
   table = 0;
-  fprintf (stderr, "\n");
+  putc ('\n', stderr);
+}
+
+/* Print PREFIX and ADDR to FILE.  */
+void
+dump_addr (FILE *file, const char *prefix, const void *addr)
+{
+  if (flag_dump_noaddr || flag_dump_unnumbered)
+    fprintf (file, "%s#", prefix);
+  else
+    fprintf (file, "%s%p", prefix, addr);
 }
 
 /* Print a node in brief fashion, with just the code, address and name.  */
 
 void
 }
 
 /* Print a node in brief fashion, with just the code, address and name.  */
 
 void
-print_node_brief (file, prefix, node, indent)
-     FILE *file;
-     const char *prefix;
-     tree node;
-     int indent;
+print_node_brief (FILE *file, const char *prefix, const_tree node, int indent)
 {
 {
-  char class;
+  enum tree_code_class class;
 
   if (node == 0)
     return;
 
   if (node == 0)
     return;
@@ -74,15 +83,21 @@ print_node_brief (file, prefix, node, indent)
      name if any.  */
   if (indent > 0)
     fprintf (file, " ");
      name if any.  */
   if (indent > 0)
     fprintf (file, " ");
-  fprintf (file, "%s <%s ", prefix, tree_code_name[(int) TREE_CODE (node)]);
-  fprintf (file, HOST_PTR_PRINTF, (char *) node);
+  fprintf (file, "%s <%s", prefix, tree_code_name[(int) TREE_CODE (node)]);
+  dump_addr (file, " ", node);
 
 
-  if (class == 'd')
+  if (class == tcc_declaration)
     {
       if (DECL_NAME (node))
        fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
     {
       if (DECL_NAME (node))
        fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
+      else if (TREE_CODE (node) == LABEL_DECL
+              && LABEL_DECL_UID (node) != -1)
+       fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
+      else
+       fprintf (file, " %c.%u", TREE_CODE (node) == CONST_DECL ? 'C' : 'D',
+                DECL_UID (node));
     }
     }
-  else if (class == 't')
+  else if (class == tcc_type)
     {
       if (TYPE_NAME (node))
        {
     {
       if (TYPE_NAME (node))
        {
@@ -100,7 +115,7 @@ print_node_brief (file, prefix, node, indent)
   /* We might as well always print the value of an integer or real.  */
   if (TREE_CODE (node) == INTEGER_CST)
     {
   /* We might as well always print the value of an integer or real.  */
   if (TREE_CODE (node) == INTEGER_CST)
     {
-      if (TREE_CONSTANT_OVERFLOW (node))
+      if (TREE_OVERFLOW (node))
        fprintf (file, " overflow");
 
       fprintf (file, " ");
        fprintf (file, " overflow");
 
       fprintf (file, " ");
@@ -108,11 +123,8 @@ print_node_brief (file, prefix, node, indent)
        fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED, TREE_INT_CST_LOW (node));
       else if (TREE_INT_CST_HIGH (node) == -1
               && TREE_INT_CST_LOW (node) != 0)
        fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED, TREE_INT_CST_LOW (node));
       else if (TREE_INT_CST_HIGH (node) == -1
               && TREE_INT_CST_LOW (node) != 0)
-       {
-         fprintf (file, "-");
-         fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED,
-                  -TREE_INT_CST_LOW (node));
-       }
+       fprintf (file, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
+                -TREE_INT_CST_LOW (node));
       else
        fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
                 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
       else
        fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
                 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
@@ -126,25 +138,34 @@ print_node_brief (file, prefix, node, indent)
 
       d = TREE_REAL_CST (node);
       if (REAL_VALUE_ISINF (d))
 
       d = TREE_REAL_CST (node);
       if (REAL_VALUE_ISINF (d))
-       fprintf (file, " Inf");
+       fprintf (file,  REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
       else if (REAL_VALUE_ISNAN (d))
        fprintf (file, " Nan");
       else
        {
       else if (REAL_VALUE_ISNAN (d))
        fprintf (file, " Nan");
       else
        {
-         char string[100];
-
-         REAL_VALUE_TO_DECIMAL (d, "%e", string);
+         char string[60];
+         real_to_decimal (string, &d, sizeof (string), 0, 1);
          fprintf (file, " %s", string);
        }
     }
          fprintf (file, " %s", string);
        }
     }
+  if (TREE_CODE (node) == FIXED_CST)
+    {
+      FIXED_VALUE_TYPE f;
+      char string[60];
+
+      if (TREE_OVERFLOW (node))
+       fprintf (file, " overflow");
+
+      f = TREE_FIXED_CST (node);
+      fixed_to_decimal (string, &f, sizeof (string));
+      fprintf (file, " %s", string);
+    }
 
   fprintf (file, ">");
 }
 
 void
 
   fprintf (file, ">");
 }
 
 void
-indent_to (file, column)
-     FILE *file;
-     int column;
+indent_to (FILE *file, int column)
 {
   int i;
 
 {
   int i;
 
@@ -159,24 +180,22 @@ indent_to (file, column)
    starting in column INDENT.  */
 
 void
    starting in column INDENT.  */
 
 void
-print_node (file, prefix, node, indent)
-     FILE *file;
-     const char *prefix;
-     tree node;
-     int indent;
+print_node (FILE *file, const char *prefix, tree node, int indent)
 {
   int hash;
   struct bucket *b;
   enum machine_mode mode;
 {
   int hash;
   struct bucket *b;
   enum machine_mode mode;
-  char class;
+  enum tree_code_class class;
   int len;
   int len;
-  int first_rtl;
   int i;
   int i;
+  expanded_location xloc;
+  enum tree_code code;
 
   if (node == 0)
     return;
 
   if (node == 0)
     return;
-
-  class = TREE_CODE_CLASS (TREE_CODE (node));
+  
+  code = TREE_CODE (node);
+  class = TREE_CODE_CLASS (code);
 
   /* Don't get too deep in nesting.  If the user wants to see deeper,
      it is easy to use the address of a lowest-level node
 
   /* Don't get too deep in nesting.  If the user wants to see deeper,
      it is easy to use the address of a lowest-level node
@@ -188,13 +207,13 @@ print_node (file, prefix, node, indent)
       return;
     }
 
       return;
     }
 
-  if (indent > 8 && (class == 't' || class == 'd'))
+  if (indent > 8 && (class == tcc_type || class == tcc_declaration))
     {
       print_node_brief (file, prefix, node, indent);
       return;
     }
 
     {
       print_node_brief (file, prefix, node, indent);
       return;
     }
 
-  /* It is unsafe to look at any other filds of an ERROR_MARK node.  */
+  /* It is unsafe to look at any other fields of an ERROR_MARK node.  */
   if (TREE_CODE (node) == ERROR_MARK)
     {
       print_node_brief (file, prefix, node, indent);
   if (TREE_CODE (node) == ERROR_MARK)
     {
       print_node_brief (file, prefix, node, indent);
@@ -212,7 +231,7 @@ print_node (file, prefix, node, indent)
       }
 
   /* Add this node to the table.  */
       }
 
   /* Add this node to the table.  */
-  b = (struct bucket *) permalloc (sizeof (struct bucket));
+  b = XNEW (struct bucket);
   b->node = node;
   b->next = table[hash];
   table[hash] = b;
   b->node = node;
   b->next = table[hash];
   table[hash] = b;
@@ -221,16 +240,22 @@ print_node (file, prefix, node, indent)
   indent_to (file, indent);
 
   /* Print the slot this node is in, and its code, and address.  */
   indent_to (file, indent);
 
   /* Print the slot this node is in, and its code, and address.  */
-  fprintf (file, "%s <%s ", prefix, tree_code_name[(int) TREE_CODE (node)]);
-  fprintf (file, HOST_PTR_PRINTF, (char *) node);
+  fprintf (file, "%s <%s", prefix, tree_code_name[(int) TREE_CODE (node)]);
+  dump_addr (file, " ", node);
 
   /* Print the name, if any.  */
 
   /* Print the name, if any.  */
-  if (class == 'd')
+  if (class == tcc_declaration)
     {
       if (DECL_NAME (node))
        fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
     {
       if (DECL_NAME (node))
        fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
+      else if (TREE_CODE (node) == LABEL_DECL
+              && LABEL_DECL_UID (node) != -1)
+       fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
+      else
+       fprintf (file, " %c.%u", TREE_CODE (node) == CONST_DECL ? 'C' : 'D',
+                DECL_UID (node));
     }
     }
-  else if (class == 't')
+  else if (class == tcc_type)
     {
       if (TYPE_NAME (node))
        {
     {
       if (TYPE_NAME (node))
        {
@@ -250,31 +275,35 @@ print_node (file, prefix, node, indent)
       if (indent <= 4)
        print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
     }
       if (indent <= 4)
        print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
     }
-  else
+  else if (!GIMPLE_TUPLE_P (node))
     {
       print_node (file, "type", TREE_TYPE (node), indent + 4);
       if (TREE_TYPE (node))
        indent_to (file, indent + 3);
     }
 
     {
       print_node (file, "type", TREE_TYPE (node), indent + 4);
       if (TREE_TYPE (node))
        indent_to (file, indent + 3);
     }
 
-  if (TREE_SIDE_EFFECTS (node))
+  if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node))
     fputs (" side-effects", file);
     fputs (" side-effects", file);
-  if (TREE_READONLY (node))
+
+  if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node))
     fputs (" readonly", file);
     fputs (" readonly", file);
-  if (TREE_CONSTANT (node))
+  if (!TYPE_P (node) && TREE_CONSTANT (node))
     fputs (" constant", file);
     fputs (" constant", file);
+  else if (TYPE_P (node) && TYPE_SIZES_GIMPLIFIED (node))
+    fputs (" sizes-gimplified", file);
+
+  if (TREE_INVARIANT (node))
+    fputs (" invariant", file);
   if (TREE_ADDRESSABLE (node))
     fputs (" addressable", file);
   if (TREE_THIS_VOLATILE (node))
     fputs (" volatile", file);
   if (TREE_ADDRESSABLE (node))
     fputs (" addressable", file);
   if (TREE_THIS_VOLATILE (node))
     fputs (" volatile", file);
-  if (TREE_UNSIGNED (node))
-    fputs (" unsigned", file);
   if (TREE_ASM_WRITTEN (node))
     fputs (" asm_written", file);
   if (TREE_USED (node))
     fputs (" used", file);
   if (TREE_NOTHROW (node))
   if (TREE_ASM_WRITTEN (node))
     fputs (" asm_written", file);
   if (TREE_USED (node))
     fputs (" used", file);
   if (TREE_NOTHROW (node))
-    fputs (" nothrow", file);
+    fputs (TYPE_P (node) ? " align-ok" : " nothrow", file);
   if (TREE_PUBLIC (node))
     fputs (" public", file);
   if (TREE_PRIVATE (node))
   if (TREE_PUBLIC (node))
     fputs (" public", file);
   if (TREE_PRIVATE (node))
@@ -285,6 +314,8 @@ print_node (file, prefix, node, indent)
     fputs (" static", file);
   if (TREE_DEPRECATED (node))
     fputs (" deprecated", file);
     fputs (" static", file);
   if (TREE_DEPRECATED (node))
     fputs (" deprecated", file);
+  if (TREE_VISITED (node))
+    fputs (" visited", file);
   if (TREE_LANG_FLAG_0 (node))
     fputs (" tree_0", file);
   if (TREE_LANG_FLAG_1 (node))
   if (TREE_LANG_FLAG_0 (node))
     fputs (" tree_0", file);
   if (TREE_LANG_FLAG_1 (node))
@@ -304,37 +335,40 @@ print_node (file, prefix, node, indent)
 
   switch (TREE_CODE_CLASS (TREE_CODE (node)))
     {
 
   switch (TREE_CODE_CLASS (TREE_CODE (node)))
     {
-    case 'd':
-      mode = DECL_MODE (node);
-
-      if (DECL_IGNORED_P (node))
-       fputs (" ignored", file);
-      if (DECL_ABSTRACT (node))
-       fputs (" abstract", file);
-      if (DECL_IN_SYSTEM_HEADER (node))
-       fputs (" in_system_header", file);
-      if (DECL_COMMON (node))
-       fputs (" common", file);
-      if (DECL_EXTERNAL (node))
-       fputs (" external", file);
-      if (DECL_WEAK (node))
-       fputs (" weak", file);
-      if (DECL_REGISTER (node) && TREE_CODE (node) != FIELD_DECL
+    case tcc_declaration:
+      if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
+       {
+         if (DECL_UNSIGNED (node))
+           fputs (" unsigned", file);
+         if (DECL_IGNORED_P (node))
+           fputs (" ignored", file);
+         if (DECL_ABSTRACT (node))
+           fputs (" abstract", file);      
+         if (DECL_EXTERNAL (node))
+           fputs (" external", file);
+         if (DECL_NONLOCAL (node))
+           fputs (" nonlocal", file);
+       }
+      if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
+       {
+         if (DECL_WEAK (node))
+           fputs (" weak", file);
+         if (DECL_IN_SYSTEM_HEADER (node))
+           fputs (" in_system_header", file);
+       }
+      if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)
+         && TREE_CODE (node) != LABEL_DECL
          && TREE_CODE (node) != FUNCTION_DECL
          && TREE_CODE (node) != FUNCTION_DECL
-         && TREE_CODE (node) != LABEL_DECL)
+         && DECL_REGISTER (node))
        fputs (" regdecl", file);
        fputs (" regdecl", file);
-      if (DECL_NONLOCAL (node))
-       fputs (" nonlocal", file);
 
       if (TREE_CODE (node) == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
        fputs (" suppress-debug", file);
 
       if (TREE_CODE (node) == FUNCTION_DECL && DECL_INLINE (node))
 
       if (TREE_CODE (node) == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
        fputs (" suppress-debug", file);
 
       if (TREE_CODE (node) == FUNCTION_DECL && DECL_INLINE (node))
-       fputs (" inline", file);
+       fputs (DECL_DECLARED_INLINE_P (node) ? " inline" : " autoinline", file);
       if (TREE_CODE (node) == FUNCTION_DECL && DECL_BUILT_IN (node))
        fputs (" built-in", file);
       if (TREE_CODE (node) == FUNCTION_DECL && DECL_BUILT_IN (node))
        fputs (" built-in", file);
-      if (TREE_CODE (node) == FUNCTION_DECL && DECL_BUILT_IN_NONANSI (node))
-       fputs (" built-in-nonansi", file);
       if (TREE_CODE (node) == FUNCTION_DECL && DECL_NO_STATIC_CHAIN (node))
        fputs (" no-static-chain", file);
 
       if (TREE_CODE (node) == FUNCTION_DECL && DECL_NO_STATIC_CHAIN (node))
        fputs (" no-static-chain", file);
 
@@ -345,98 +379,133 @@ print_node (file, prefix, node, indent)
       if (TREE_CODE (node) == FIELD_DECL && DECL_NONADDRESSABLE_P (node))
        fputs (" nonaddressable", file);
 
       if (TREE_CODE (node) == FIELD_DECL && DECL_NONADDRESSABLE_P (node))
        fputs (" nonaddressable", file);
 
-      if (TREE_CODE (node) == LABEL_DECL && DECL_TOO_LATE (node))
-       fputs (" too-late", file);
       if (TREE_CODE (node) == LABEL_DECL && DECL_ERROR_ISSUED (node))
        fputs (" error-issued", file);
 
       if (TREE_CODE (node) == VAR_DECL && DECL_IN_TEXT_SECTION (node))
        fputs (" in-text-section", file);
       if (TREE_CODE (node) == LABEL_DECL && DECL_ERROR_ISSUED (node))
        fputs (" error-issued", file);
 
       if (TREE_CODE (node) == VAR_DECL && DECL_IN_TEXT_SECTION (node))
        fputs (" in-text-section", file);
+      if (TREE_CODE (node) == VAR_DECL && DECL_COMMON (node))
+       fputs (" common", file);
+      if (TREE_CODE (node) == VAR_DECL && DECL_THREAD_LOCAL_P (node))
+       {
+         enum tls_model kind = DECL_TLS_MODEL (node);
+         switch (kind)
+           {
+             case TLS_MODEL_GLOBAL_DYNAMIC:
+               fputs (" tls-global-dynamic", file);
+               break;
+             case TLS_MODEL_LOCAL_DYNAMIC:
+               fputs (" tls-local-dynamic", file);
+               break;
+             case TLS_MODEL_INITIAL_EXEC:
+               fputs (" tls-initial-exec", file);
+               break;
+             case TLS_MODEL_LOCAL_EXEC:
+               fputs (" tls-local-exec", file);
+               break;
+             default:
+               gcc_unreachable ();
+           }
+       }
 
 
-      if (TREE_CODE (node) == PARM_DECL && DECL_TRANSPARENT_UNION (node))
-       fputs (" transparent-union", file);
+      if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
+       {         
+         if (DECL_VIRTUAL_P (node))
+           fputs (" virtual", file);
+         if (DECL_PRESERVE_P (node))
+           fputs (" preserve", file);
+         if (DECL_NO_TBAA_P (node))
+           fputs (" no-tbaa", file);
+         if (DECL_LANG_FLAG_0 (node))
+           fputs (" decl_0", file);
+         if (DECL_LANG_FLAG_1 (node))
+           fputs (" decl_1", file);
+         if (DECL_LANG_FLAG_2 (node))
+           fputs (" decl_2", file);
+         if (DECL_LANG_FLAG_3 (node))
+           fputs (" decl_3", file);
+         if (DECL_LANG_FLAG_4 (node))
+           fputs (" decl_4", file);
+         if (DECL_LANG_FLAG_5 (node))
+           fputs (" decl_5", file);
+         if (DECL_LANG_FLAG_6 (node))
+           fputs (" decl_6", file);
+         if (DECL_LANG_FLAG_7 (node))
+           fputs (" decl_7", file);
+         
+         mode = DECL_MODE (node);
+         fprintf (file, " %s", GET_MODE_NAME (mode));
+       }
 
 
-      if (DECL_VIRTUAL_P (node))
-       fputs (" virtual", file);
-      if (DECL_DEFER_OUTPUT (node))
+      if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)  && DECL_DEFER_OUTPUT (node))
        fputs (" defer-output", file);
 
        fputs (" defer-output", file);
 
-      if (DECL_LANG_FLAG_0 (node))
-       fputs (" decl_0", file);
-      if (DECL_LANG_FLAG_1 (node))
-       fputs (" decl_1", file);
-      if (DECL_LANG_FLAG_2 (node))
-       fputs (" decl_2", file);
-      if (DECL_LANG_FLAG_3 (node))
-       fputs (" decl_3", file);
-      if (DECL_LANG_FLAG_4 (node))
-       fputs (" decl_4", file);
-      if (DECL_LANG_FLAG_5 (node))
-       fputs (" decl_5", file);
-      if (DECL_LANG_FLAG_6 (node))
-       fputs (" decl_6", file);
-      if (DECL_LANG_FLAG_7 (node))
-       fputs (" decl_7", file);
 
 
-      fprintf (file, " %s", GET_MODE_NAME (mode));
-      fprintf (file, " file %s line %d",
-              DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
+      xloc = expand_location (DECL_SOURCE_LOCATION (node));
+      fprintf (file, " file %s line %d col %d", xloc.file, xloc.line,
+              xloc.column);
 
 
-      print_node (file, "size", DECL_SIZE (node), indent + 4);
-      print_node (file, "unit size", DECL_SIZE_UNIT (node), indent + 4);
-      
-      if (TREE_CODE (node) != FUNCTION_DECL
-         || DECL_INLINE (node) || DECL_BUILT_IN (node))
-       indent_to (file, indent + 3);
-
-      if (TREE_CODE (node) != FUNCTION_DECL)
-       {
+      if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
+       {         
+         print_node (file, "size", DECL_SIZE (node), indent + 4);
+         print_node (file, "unit size", DECL_SIZE_UNIT (node), indent + 4);
+         
+         if (TREE_CODE (node) != FUNCTION_DECL
+             || DECL_INLINE (node) || DECL_BUILT_IN (node))
+           indent_to (file, indent + 3);
+         
          if (DECL_USER_ALIGN (node))
            fprintf (file, " user");
          if (DECL_USER_ALIGN (node))
            fprintf (file, " user");
-
+         
          fprintf (file, " align %d", DECL_ALIGN (node));
          if (TREE_CODE (node) == FIELD_DECL)
          fprintf (file, " align %d", DECL_ALIGN (node));
          if (TREE_CODE (node) == FIELD_DECL)
+           fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED,
+                    DECL_OFFSET_ALIGN (node));
+
+         if (TREE_CODE (node) == FUNCTION_DECL && DECL_BUILT_IN (node))
            {
            {
-             fprintf (file, " offset_align ");
-             fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED,
-                      DECL_OFFSET_ALIGN (node));
+             if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)
+               fprintf (file, " built-in BUILT_IN_MD %d", DECL_FUNCTION_CODE (node));
+             else
+               fprintf (file, " built-in %s:%s",
+                        built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],
+                        built_in_names[(int) DECL_FUNCTION_CODE (node)]);
            }
            }
+         
+         if (DECL_POINTER_ALIAS_SET_KNOWN_P (node))
+           fprintf (file, " alias set " HOST_WIDE_INT_PRINT_DEC,
+                    (HOST_WIDE_INT) DECL_POINTER_ALIAS_SET (node));
        }
        }
-      else if (DECL_BUILT_IN (node))
-       {
-         if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)
-           fprintf (file, " built-in BUILT_IN_MD %d", DECL_FUNCTION_CODE (node));
-         else
-           fprintf (file, " built-in %s:%s",
-                    built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],
-                    built_in_names[(int) DECL_FUNCTION_CODE (node)]);
-       }
-
-      if (DECL_POINTER_ALIAS_SET_KNOWN_P (node))
-       {
-         fprintf (file, " alias set ");
-         fprintf (file, HOST_WIDE_INT_PRINT_DEC, 
-                  DECL_POINTER_ALIAS_SET (node));
-       }
-
       if (TREE_CODE (node) == FIELD_DECL)
        {
          print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4);
          print_node (file, "bit offset", DECL_FIELD_BIT_OFFSET (node),
                      indent + 4);
       if (TREE_CODE (node) == FIELD_DECL)
        {
          print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4);
          print_node (file, "bit offset", DECL_FIELD_BIT_OFFSET (node),
                      indent + 4);
+         if (DECL_BIT_FIELD_TYPE (node))
+           print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node),
+                       indent + 4);
        }
 
       print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
        }
 
       print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
-      print_node_brief (file, "attributes",
-                       DECL_ATTRIBUTES (node), indent + 4);
-      print_node_brief (file, "abstract_origin",
-                       DECL_ABSTRACT_ORIGIN (node), indent + 4);
 
 
-      print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
-      print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
-      print_node_brief (file, "initial", DECL_INITIAL (node), indent + 4);
+      if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) 
+       {
+         print_node_brief (file, "attributes",
+                           DECL_ATTRIBUTES (node), indent + 4);
+         print_node_brief (file, "initial", DECL_INITIAL (node), indent + 4);
+       }
+      if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
+       {
+         print_node_brief (file, "abstract_origin",
+                           DECL_ABSTRACT_ORIGIN (node), indent + 4);
+       }
+      if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
+       {
+         print_node (file, "arguments", DECL_ARGUMENT_FLD (node), indent + 4);
+         print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
+       }
 
 
-      (*lang_hooks.print_decl) (file, node, indent);
+      lang_hooks.print_decl (file, node, indent);
 
       if (DECL_RTL_SET_P (node))
        {
 
       if (DECL_RTL_SET_P (node))
        {
@@ -447,8 +516,6 @@ print_node (file, prefix, node, indent)
       if (TREE_CODE (node) == PARM_DECL)
        {
          print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4);
       if (TREE_CODE (node) == PARM_DECL)
        {
          print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4);
-         print_node (file, "arg-type-as-written",
-                     DECL_ARG_TYPE_AS_WRITTEN (node), indent + 4);
 
          if (DECL_INCOMING_RTL (node) != 0)
            {
 
          if (DECL_INCOMING_RTL (node) != 0)
            {
@@ -458,13 +525,25 @@ print_node (file, prefix, node, indent)
            }
        }
       else if (TREE_CODE (node) == FUNCTION_DECL
            }
        }
       else if (TREE_CODE (node) == FUNCTION_DECL
-              && DECL_SAVED_INSNS (node) != 0)
+              && DECL_STRUCT_FUNCTION (node) != 0)
        {
          indent_to (file, indent + 4);
        {
          indent_to (file, indent + 4);
-         fprintf (file, "saved-insns ");
-         fprintf (file, HOST_PTR_PRINTF, (char *) DECL_SAVED_INSNS (node));
+         dump_addr (file, "saved-insns ", DECL_STRUCT_FUNCTION (node));
        }
 
        }
 
+      if ((TREE_CODE (node) == VAR_DECL || TREE_CODE (node) == PARM_DECL)
+         && DECL_HAS_VALUE_EXPR_P (node))
+       print_node (file, "value-expr", DECL_VALUE_EXPR (node), indent + 4);
+
+      if (TREE_CODE (node) == STRUCT_FIELD_TAG)
+       {
+         fprintf (file, " sft size " HOST_WIDE_INT_PRINT_DEC, 
+                  SFT_SIZE (node));
+         fprintf (file, " sft offset " HOST_WIDE_INT_PRINT_DEC,
+                  SFT_OFFSET (node));
+         print_node_brief (file, "parent var", SFT_PARENT_VAR (node), 
+                           indent + 4);
+       }
       /* Print the decl chain only if decl is at second level.  */
       if (indent == 4)
        print_node (file, "chain", TREE_CHAIN (node), indent + 4);
       /* Print the decl chain only if decl is at second level.  */
       if (indent == 4)
        print_node (file, "chain", TREE_CHAIN (node), indent + 4);
@@ -472,7 +551,10 @@ print_node (file, prefix, node, indent)
        print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
       break;
 
        print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
       break;
 
-    case 't':
+    case tcc_type:
+      if (TYPE_UNSIGNED (node))
+       fputs (" unsigned", file);
+
       /* The no-force-blk flag is used for different things in
         different types.  */
       if ((TREE_CODE (node) == RECORD_TYPE
       /* The no-force-blk flag is used for different things in
         different types.  */
       if ((TREE_CODE (node) == RECORD_TYPE
@@ -499,13 +581,13 @@ print_node (file, prefix, node, indent)
       else if (TREE_CODE (node) == ARRAY_TYPE
               && TYPE_NONALIASED_COMPONENT (node))
        fputs (" nonaliased-component", file);
       else if (TREE_CODE (node) == ARRAY_TYPE
               && TYPE_NONALIASED_COMPONENT (node))
        fputs (" nonaliased-component", file);
-      else if (TREE_CODE (node) == FUNCTION_TYPE
-              && TYPE_AMBIENT_BOUNDEDNESS (node))
-       fputs (" ambient-boundedness", file);
 
       if (TYPE_PACKED (node))
        fputs (" packed", file);
 
 
       if (TYPE_PACKED (node))
        fputs (" packed", file);
 
+      if (TYPE_RESTRICT (node))
+       fputs (" restrict", file);
+
       if (TYPE_LANG_FLAG_0 (node))
        fputs (" type_0", file);
       if (TYPE_LANG_FLAG_1 (node))
       if (TYPE_LANG_FLAG_0 (node))
        fputs (" type_0", file);
       if (TYPE_LANG_FLAG_1 (node))
@@ -531,14 +613,19 @@ print_node (file, prefix, node, indent)
       if (TYPE_USER_ALIGN (node))
        fprintf (file, " user");
 
       if (TYPE_USER_ALIGN (node))
        fprintf (file, " user");
 
-      fprintf (file, " align %d", TYPE_ALIGN (node));
-      fprintf (file, " symtab %d", TYPE_SYMTAB_ADDRESS (node));
-      fprintf (file, " alias set ");
-      fprintf (file, HOST_WIDE_INT_PRINT_DEC, TYPE_ALIAS_SET (node));
+      fprintf (file, " align %d symtab %d alias set " HOST_WIDE_INT_PRINT_DEC,
+              TYPE_ALIGN (node), TYPE_SYMTAB_ADDRESS (node),
+              (HOST_WIDE_INT) TYPE_ALIAS_SET (node));
 
 
+      if (TYPE_STRUCTURAL_EQUALITY_P (node))
+       fprintf (file, " structural equality");
+      else
+       dump_addr (file, " canonical type ", TYPE_CANONICAL (node));
+      
       print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);
 
       print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);
 
-      if (INTEGRAL_TYPE_P (node) || TREE_CODE (node) == REAL_TYPE)
+      if (INTEGRAL_TYPE_P (node) || TREE_CODE (node) == REAL_TYPE
+         || TREE_CODE (node) == FIXED_POINT_TYPE)
        {
          fprintf (file, " precision %d", TYPE_PRECISION (node));
          print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4);
        {
          fprintf (file, " precision %d", TYPE_PRECISION (node));
          print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4);
@@ -547,8 +634,10 @@ print_node (file, prefix, node, indent)
 
       if (TREE_CODE (node) == ENUMERAL_TYPE)
        print_node (file, "values", TYPE_VALUES (node), indent + 4);
 
       if (TREE_CODE (node) == ENUMERAL_TYPE)
        print_node (file, "values", TYPE_VALUES (node), indent + 4);
-      else if (TREE_CODE (node) == ARRAY_TYPE || TREE_CODE (node) == SET_TYPE)
+      else if (TREE_CODE (node) == ARRAY_TYPE)
        print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
        print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
+      else if (TREE_CODE (node) == VECTOR_TYPE)
+       fprintf (file, " nunits %d", (int) TYPE_VECTOR_SUBPARTS (node));
       else if (TREE_CODE (node) == RECORD_TYPE
               || TREE_CODE (node) == UNION_TYPE
               || TREE_CODE (node) == QUAL_UNION_TYPE)
       else if (TREE_CODE (node) == RECORD_TYPE
               || TREE_CODE (node) == UNION_TYPE
               || TREE_CODE (node) == QUAL_UNION_TYPE)
@@ -568,7 +657,7 @@ print_node (file, prefix, node, indent)
       if (TYPE_CONTEXT (node))
        print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
 
       if (TYPE_CONTEXT (node))
        print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
 
-      (*lang_hooks.print_type) (file, node, indent);
+      lang_hooks.print_type (file, node, indent);
 
       if (TYPE_POINTER_TO (node) || TREE_CHAIN (node))
        indent_to (file, indent + 3);
 
       if (TYPE_POINTER_TO (node) || TREE_CHAIN (node))
        indent_to (file, indent + 3);
@@ -580,21 +669,15 @@ print_node (file, prefix, node, indent)
       print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
       break;
 
       print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
       break;
 
-    case 'b':
-      print_node (file, "vars", BLOCK_VARS (node), indent + 4);
-      print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node), indent + 4);
-      print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4);
-      print_node (file, "chain", BLOCK_CHAIN (node), indent + 4);
-      print_node (file, "abstract_origin",
-                 BLOCK_ABSTRACT_ORIGIN (node), indent + 4);
-      break;
-
-    case 'e':
-    case '<':
-    case '1':
-    case '2':
-    case 'r':
-    case 's':
+    case tcc_expression:
+    case tcc_comparison:
+    case tcc_unary:
+    case tcc_binary:
+    case tcc_reference:
+    case tcc_statement:
+    case tcc_vl_exp:
+      if (TREE_CODE (node) == BIT_FIELD_REF && BIT_FIELD_REF_UNSIGNED (node))
+       fputs (" unsigned", file);
       if (TREE_CODE (node) == BIND_EXPR)
        {
          print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
       if (TREE_CODE (node) == BIND_EXPR)
        {
          print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
@@ -602,51 +685,55 @@ print_node (file, prefix, node, indent)
          print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
          break;
        }
          print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
          break;
        }
-
-      len = TREE_CODE_LENGTH (TREE_CODE (node));
-
-      /* Some nodes contain rtx's, not trees,
-        after a certain point.  Print the rtx's as rtx's.  */
-      first_rtl = first_rtl_op (TREE_CODE (node));
-
-      for (i = 0; i < len; i++)
+      if (TREE_CODE (node) == CALL_EXPR)
        {
        {
-         if (i >= first_rtl)
+         call_expr_arg_iterator iter;
+         tree arg;
+         print_node (file, "fn", CALL_EXPR_FN (node), indent + 4);
+         print_node (file, "static_chain", CALL_EXPR_STATIC_CHAIN (node),
+                     indent + 4);
+         i = 0;
+         FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
            {
            {
-             indent_to (file, indent + 4);
-             fprintf (file, "rtl %d ", i);
-             if (TREE_OPERAND (node, i))
-               print_rtl (file, (struct rtx_def *) TREE_OPERAND (node, i));
-             else
-               fprintf (file, "(nil)");
-             fprintf (file, "\n");
+             char temp[10];
+             sprintf (temp, "arg %d", i);
+             print_node (file, temp, arg, indent + 4);
+             i++;
            }
            }
-         else
+       }
+      else
+       {
+         len = TREE_OPERAND_LENGTH (node);
+
+         for (i = 0; i < len; i++)
            {
              char temp[10];
            {
              char temp[10];
-
+             
              sprintf (temp, "arg %d", i);
              print_node (file, temp, TREE_OPERAND (node, i), indent + 4);
            }
        }
              sprintf (temp, "arg %d", i);
              print_node (file, temp, TREE_OPERAND (node, i), indent + 4);
            }
        }
+      print_node (file, "chain", TREE_CHAIN (node), indent + 4);
+      break;
 
 
-      if (TREE_CODE (node) == EXPR_WITH_FILE_LOCATION)
+    case tcc_gimple_stmt:
+      len = TREE_CODE_LENGTH (TREE_CODE (node));
+
+      for (i = 0; i < len; i++)
        {
        {
-         indent_to (file, indent+4);
-          fprintf (file, "%s:%d:%d", 
-                  (EXPR_WFL_FILENAME_NODE (node ) ?
-                   EXPR_WFL_FILENAME (node) : "(no file info)"),
-                  EXPR_WFL_LINENO (node), EXPR_WFL_COLNO (node));
+         char temp[10];
+
+         sprintf (temp, "arg %d", i);
+         print_node (file, temp, GIMPLE_STMT_OPERAND (node, i), indent + 4);
        }
        }
-      print_node (file, "chain", TREE_CHAIN (node), indent + 4);
       break;
 
       break;
 
-    case 'c':
-    case 'x':
+    case tcc_constant:
+    case tcc_exceptional:
       switch (TREE_CODE (node))
        {
        case INTEGER_CST:
       switch (TREE_CODE (node))
        {
        case INTEGER_CST:
-         if (TREE_CONSTANT_OVERFLOW (node))
+         if (TREE_OVERFLOW (node))
            fprintf (file, " overflow");
 
          fprintf (file, " ");
            fprintf (file, " overflow");
 
          fprintf (file, " ");
@@ -655,11 +742,8 @@ print_node (file, prefix, node, indent)
                     TREE_INT_CST_LOW (node));
          else if (TREE_INT_CST_HIGH (node) == -1
                   && TREE_INT_CST_LOW (node) != 0)
                     TREE_INT_CST_LOW (node));
          else if (TREE_INT_CST_HIGH (node) == -1
                   && TREE_INT_CST_LOW (node) != 0)
-           {
-             fprintf (file, "-");
-             fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED,
-                      -TREE_INT_CST_LOW (node));
-           }
+           fprintf (file, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
+                    -TREE_INT_CST_LOW (node));
          else
            fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
                     TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
          else
            fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
                     TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
@@ -674,19 +758,32 @@ print_node (file, prefix, node, indent)
 
            d = TREE_REAL_CST (node);
            if (REAL_VALUE_ISINF (d))
 
            d = TREE_REAL_CST (node);
            if (REAL_VALUE_ISINF (d))
-             fprintf (file, " Inf");
+             fprintf (file,  REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
            else if (REAL_VALUE_ISNAN (d))
              fprintf (file, " Nan");
            else
              {
            else if (REAL_VALUE_ISNAN (d))
              fprintf (file, " Nan");
            else
              {
-               char string[100];
-
-               REAL_VALUE_TO_DECIMAL (d, "%e", string);
+               char string[64];
+               real_to_decimal (string, &d, sizeof (string), 0, 1);
                fprintf (file, " %s", string);
              }
          }
          break;
 
                fprintf (file, " %s", string);
              }
          }
          break;
 
+       case FIXED_CST:
+         {
+           FIXED_VALUE_TYPE f;
+           char string[64];
+
+           if (TREE_OVERFLOW (node))
+             fprintf (file, " overflow");
+
+           f = TREE_FIXED_CST (node);
+           fixed_to_decimal (string, &f, sizeof (string));
+           fprintf (file, " %s", string);
+         }
+         break;
+
        case VECTOR_CST:
          {
            tree vals = TREE_VECTOR_CST_ELTS (node);
        case VECTOR_CST:
          {
            tree vals = TREE_VECTOR_CST_ELTS (node);
@@ -709,7 +806,20 @@ print_node (file, prefix, node, indent)
          break;
 
        case STRING_CST:
          break;
 
        case STRING_CST:
-         fprintf (file, " \"%s\"", TREE_STRING_POINTER (node));
+         {
+           const char *p = TREE_STRING_POINTER (node);
+           int i = TREE_STRING_LENGTH (node);
+           fputs (" \"", file);
+           while (--i >= 0)
+             {
+               char ch = *p++;
+               if (ch >= ' ' && ch < 127)
+                 putc (ch, file);
+               else
+                 fprintf(file, "\\%03o", ch & 0xFF);
+             }
+           fputc ('\"', file);
+         }
          /* Print the chain at second level.  */
          if (indent == 4)
            print_node (file, "chain", TREE_CHAIN (node), indent + 4);
          /* Print the chain at second level.  */
          if (indent == 4)
            print_node (file, "chain", TREE_CHAIN (node), indent + 4);
@@ -718,7 +828,7 @@ print_node (file, prefix, node, indent)
          break;
 
        case IDENTIFIER_NODE:
          break;
 
        case IDENTIFIER_NODE:
-         (*lang_hooks.print_identifier) (file, node, indent);
+         lang_hooks.print_identifier (file, node, indent);
          break;
 
        case TREE_LIST:
          break;
 
        case TREE_LIST:
@@ -739,14 +849,106 @@ print_node (file, prefix, node, indent)
              }
          break;
 
              }
          break;
 
+       case CONSTRUCTOR:
+         {
+           unsigned HOST_WIDE_INT cnt;
+           tree index, value;
+           len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node));
+           fprintf (file, " lngt %d", len);
+           FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node),
+                                     cnt, index, value)
+             {
+               print_node (file, "idx", index, indent + 4);
+               print_node (file, "val", value, indent + 4);
+             }
+         }
+         break;
+
+       case STATEMENT_LIST:
+         dump_addr (file, " head ", node->stmt_list.head);
+         dump_addr (file, " tail ", node->stmt_list.tail);
+         fprintf (file, " stmts");
+         {
+           tree_stmt_iterator i;
+           for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i))
+             {
+               /* Not printing the addresses of the (not-a-tree)
+                  'struct tree_stmt_list_node's.  */
+               dump_addr (file, " ", tsi_stmt (i));
+             }
+           fprintf (file, "\n");
+           for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i))
+             {
+               /* Not printing the addresses of the (not-a-tree)
+                  'struct tree_stmt_list_node's.  */
+               print_node (file, "stmt", tsi_stmt (i), indent + 4);
+             }
+         }
+         print_node (file, "chain", TREE_CHAIN (node), indent + 4);
+         break;
+
+       case BLOCK:
+         print_node (file, "vars", BLOCK_VARS (node), indent + 4);
+         print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node),
+                     indent + 4);
+         print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4);
+         print_node (file, "chain", BLOCK_CHAIN (node), indent + 4);
+         print_node (file, "abstract_origin",
+                     BLOCK_ABSTRACT_ORIGIN (node), indent + 4);
+         break;
+
+       case SSA_NAME:
+         print_node_brief (file, "var", SSA_NAME_VAR (node), indent + 4);
+         print_node_brief (file, "def_stmt",
+                           SSA_NAME_DEF_STMT (node), indent + 4);
+
+         indent_to (file, indent + 4);
+         fprintf (file, "version %u", SSA_NAME_VERSION (node));
+         if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
+           fprintf (file, " in-abnormal-phi");
+         if (SSA_NAME_IN_FREE_LIST (node))
+           fprintf (file, " in-free-list");
+
+         if (SSA_NAME_PTR_INFO (node)
+             || SSA_NAME_VALUE (node))
+           {
+             indent_to (file, indent + 3);
+             if (SSA_NAME_PTR_INFO (node))
+               dump_addr (file, " ptr-info ", SSA_NAME_PTR_INFO (node));
+             if (SSA_NAME_VALUE (node))
+               dump_addr (file, " value ", SSA_NAME_VALUE (node));
+           }
+         break;
+
+       case OMP_CLAUSE:
+           {
+             int i;
+             fprintf (file, " %s",
+                      omp_clause_code_name[OMP_CLAUSE_CODE (node)]);
+             for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (node)]; i++)
+               {
+                 indent_to (file, indent + 4);
+                 fprintf (file, "op %d:", i);
+                 print_node_brief (file, "", OMP_CLAUSE_OPERAND (node, i), 0);
+               }
+           }
+         break;
+
        default:
        default:
-         if (TREE_CODE_CLASS (TREE_CODE (node)) == 'x')
-           (*lang_hooks.print_xnode) (file, node, indent);
+         if (EXCEPTIONAL_CLASS_P (node))
+           lang_hooks.print_xnode (file, node, indent);
          break;
        }
 
       break;
     }
 
          break;
        }
 
       break;
     }
 
+  if (EXPR_HAS_LOCATION (node))
+    {
+      expanded_location xloc = expand_location (EXPR_LOCATION (node));
+      indent_to (file, indent+4);
+      fprintf (file, "%s:%d:%d", xloc.file, xloc.line, xloc.column);
+    }
+
   fprintf (file, ">");
 }
   fprintf (file, ">");
 }
About OSDN
Find Software
Develop Software
Help