Initial checkin of GCC 4.9.0 from trunk (r208799).

Change-Id: I48a3c08bb98542aa215912a75f03c0890e497dba

1 files changed, 777 insertions, 0 deletions

diff --git a/gcc-4.9/gcc/tree-dump.c b/gcc-4.9/gcc/tree-dump.c
new file mode 100644
index 000000000..fec493db3
--- /dev/null
+++ b/gcc-4.9/gcc/tree-dump.c
@@ -0,0 +1,777 @@
+/* Tree-dumping functionality for intermediate representation.
+   Copyright (C) 1999-2014 Free Software Foundation, Inc.
+   Written by Mark Mitchell <mark@codesourcery.com>
+
+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 3, or (at your option) any later
+version.
+
+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 GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "tree.h"
+#include "splay-tree.h"
+#include "filenames.h"
+#include "tree-dump.h"
+#include "langhooks.h"
+#include "tree-iterator.h"
+#include "tree-pretty-print.h"
+#include "tree-cfg.h"
+
+static unsigned int queue (dump_info_p, const_tree, int);
+static void dump_index (dump_info_p, unsigned int);
+static void dequeue_and_dump (dump_info_p);
+static void dump_new_line (dump_info_p);
+static void dump_maybe_newline (dump_info_p);
+
+/* Add T to the end of the queue of nodes to dump.  Returns the index
+   assigned to T.  */
+
+static unsigned int
+queue (dump_info_p di, const_tree t, int flags)
+{
+  dump_queue_p dq;
+  dump_node_info_p dni;
+  unsigned int index;
+
+  /* Assign the next available index to T.  */
+  index = ++di->index;
+
+  /* Obtain a new queue node.  */
+  if (di->free_list)
+    {
+      dq = di->free_list;
+      di->free_list = dq->next;
+    }
+  else
+    dq = XNEW (struct dump_queue);
+
+  /* Create a new entry in the splay-tree.  */
+  dni = XNEW (struct dump_node_info);
+  dni->index = index;
+  dni->binfo_p = ((flags & DUMP_BINFO) != 0);
+  dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t,
+				(splay_tree_value) dni);
+
+  /* Add it to the end of the queue.  */
+  dq->next = 0;
+  if (!di->queue_end)
+    di->queue = dq;
+  else
+    di->queue_end->next = dq;
+  di->queue_end = dq;
+
+  /* Return the index.  */
+  return index;
+}
+
+static void
+dump_index (dump_info_p di, unsigned int index)
+{
+  fprintf (di->stream, "@%-6u ", index);
+  di->column += 8;
+}
+
+/* If T has not already been output, queue it for subsequent output.
+   FIELD is a string to print before printing the index.  Then, the
+   index of T is printed.  */
+
+void
+queue_and_dump_index (dump_info_p di, const char *field, const_tree t, int flags)
+{
+  unsigned int index;
+  splay_tree_node n;
+
+  /* If there's no node, just return.  This makes for fewer checks in
+     our callers.  */
+  if (!t)
+    return;
+
+  /* See if we've already queued or dumped this node.  */
+  n = splay_tree_lookup (di->nodes, (splay_tree_key) t);
+  if (n)
+    index = ((dump_node_info_p) n->value)->index;
+  else
+    /* If we haven't, add it to the queue.  */
+    index = queue (di, t, flags);
+
+  /* Print the index of the node.  */
+  dump_maybe_newline (di);
+  fprintf (di->stream, "%-4s: ", field);
+  di->column += 6;
+  dump_index (di, index);
+}
+
+/* Dump the type of T.  */
+
+void
+queue_and_dump_type (dump_info_p di, const_tree t)
+{
+  queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
+}
+
+/* Dump column control */
+#define SOL_COLUMN 25		/* Start of line column.  */
+#define EOL_COLUMN 55		/* End of line column.  */
+#define COLUMN_ALIGNMENT 15	/* Alignment.  */
+
+/* Insert a new line in the dump output, and indent to an appropriate
+   place to start printing more fields.  */
+
+static void
+dump_new_line (dump_info_p di)
+{
+  fprintf (di->stream, "\n%*s", SOL_COLUMN, "");
+  di->column = SOL_COLUMN;
+}
+
+/* If necessary, insert a new line.  */
+
+static void
+dump_maybe_newline (dump_info_p di)
+{
+  int extra;
+
+  /* See if we need a new line.  */
+  if (di->column > EOL_COLUMN)
+    dump_new_line (di);
+  /* See if we need any padding.  */
+  else if ((extra = (di->column - SOL_COLUMN) % COLUMN_ALIGNMENT) != 0)
+    {
+      fprintf (di->stream, "%*s", COLUMN_ALIGNMENT - extra, "");
+      di->column += COLUMN_ALIGNMENT - extra;
+    }
+}
+
+/* Dump FUNCTION_DECL FN as tree dump PHASE.  */
+
+void
+dump_function (int phase, tree fn)
+{
+  FILE *stream;
+  int flags;
+
+  stream = dump_begin (phase, &flags);
+  if (stream)
+    {
+      dump_function_to_file (fn, stream, flags);
+      dump_end (phase, stream);
+    }
+}
+
+/* Dump pointer PTR using FIELD to identify it.  */
+
+void
+dump_pointer (dump_info_p di, const char *field, void *ptr)
+{
+  dump_maybe_newline (di);
+  fprintf (di->stream, "%-4s: %-8" HOST_WIDE_INT_PRINT "x ", field,
+	   (unsigned HOST_WIDE_INT) (uintptr_t) ptr);
+  di->column += 15;
+}
+
+/* Dump integer I using FIELD to identify it.  */
+
+void
+dump_int (dump_info_p di, const char *field, int i)
+{
+  dump_maybe_newline (di);
+  fprintf (di->stream, "%-4s: %-7d ", field, i);
+  di->column += 14;
+}
+
+/* Dump the floating point value R, using FIELD to identify it.  */
+
+static void
+dump_real (dump_info_p di, const char *field, const REAL_VALUE_TYPE *r)
+{
+  char buf[32];
+  real_to_decimal (buf, r, sizeof (buf), 0, true);
+  dump_maybe_newline (di);
+  fprintf (di->stream, "%-4s: %s ", field, buf);
+  di->column += strlen (buf) + 7;
+}
+
+/* Dump the fixed-point value F, using FIELD to identify it.  */
+
+static void
+dump_fixed (dump_info_p di, const char *field, const FIXED_VALUE_TYPE *f)
+{
+  char buf[32];
+  fixed_to_decimal (buf, f, sizeof (buf));
+  dump_maybe_newline (di);
+  fprintf (di->stream, "%-4s: %s ", field, buf);
+  di->column += strlen (buf) + 7;
+}
+
+
+/* Dump the string S.  */
+
+void
+dump_string (dump_info_p di, const char *string)
+{
+  dump_maybe_newline (di);
+  fprintf (di->stream, "%-13s ", string);
+  if (strlen (string) > 13)
+    di->column += strlen (string) + 1;
+  else
+    di->column += 14;
+}
+
+/* Dump the string field S.  */
+
+void
+dump_string_field (dump_info_p di, const char *field, const char *string)
+{
+  dump_maybe_newline (di);
+  fprintf (di->stream, "%-4s: %-7s ", field, string);
+  if (strlen (string) > 7)
+    di->column += 6 + strlen (string) + 1;
+  else
+    di->column += 14;
+}
+
+/* Dump the next node in the queue.  */
+
+static void
+dequeue_and_dump (dump_info_p di)
+{
+  dump_queue_p dq;
+  splay_tree_node stn;
+  dump_node_info_p dni;
+  tree t;
+  unsigned int index;
+  enum tree_code code;
+  enum tree_code_class code_class;
+  const char* code_name;
+
+  /* Get the next node from the queue.  */
+  dq = di->queue;
+  stn = dq->node;
+  t = (tree) stn->key;
+  dni = (dump_node_info_p) stn->value;
+  index = dni->index;
+
+  /* Remove the node from the queue, and put it on the free list.  */
+  di->queue = dq->next;
+  if (!di->queue)
+    di->queue_end = 0;
+  dq->next = di->free_list;
+  di->free_list = dq;
+
+  /* Print the node index.  */
+  dump_index (di, index);
+  /* And the type of node this is.  */
+  if (dni->binfo_p)
+    code_name = "binfo";
+  else
+    code_name = get_tree_code_name (TREE_CODE (t));
+  fprintf (di->stream, "%-16s ", code_name);
+  di->column = 25;
+
+  /* Figure out what kind of node this is.  */
+  code = TREE_CODE (t);
+  code_class = TREE_CODE_CLASS (code);
+
+  /* Although BINFOs are TREE_VECs, we dump them specially so as to be
+     more informative.  */
+  if (dni->binfo_p)
+    {
+      unsigned ix;
+      tree base;
+      vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (t);
+
+      dump_child ("type", BINFO_TYPE (t));
+
+      if (BINFO_VIRTUAL_P (t))
+	dump_string_field (di, "spec", "virt");
+
+      dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
+      for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)
+	{
+	  tree access = (accesses ? (*accesses)[ix] : access_public_node);
+	  const char *string = NULL;
+
+	  if (access == access_public_node)
+	    string = "pub";
+	  else if (access == access_protected_node)
+	    string = "prot";
+	  else if (access == access_private_node)
+	    string = "priv";
+	  else
+	    gcc_unreachable ();
+
+	  dump_string_field (di, "accs", string);
+	  queue_and_dump_index (di, "binf", base, DUMP_BINFO);
+	}
+
+      goto done;
+    }
+
+  /* We can knock off a bunch of expression nodes in exactly the same
+     way.  */
+  if (IS_EXPR_CODE_CLASS (code_class))
+    {
+      /* If we're dumping children, dump them now.  */
+      queue_and_dump_type (di, t);
+
+      switch (code_class)
+	{
+	case tcc_unary:
+	  dump_child ("op 0", TREE_OPERAND (t, 0));
+	  break;
+
+	case tcc_binary:
+	case tcc_comparison:
+	  dump_child ("op 0", TREE_OPERAND (t, 0));
+	  dump_child ("op 1", TREE_OPERAND (t, 1));
+	  break;
+
+	case tcc_expression:
+	case tcc_reference:
+	case tcc_statement:
+	case tcc_vl_exp:
+	  /* These nodes are handled explicitly below.  */
+	  break;
+
+	default:
+	  gcc_unreachable ();
+	}
+    }
+  else if (DECL_P (t))
+    {
+      expanded_location xloc;
+      /* All declarations have names.  */
+      if (DECL_NAME (t))
+	dump_child ("name", DECL_NAME (t));
+      if (DECL_ASSEMBLER_NAME_SET_P (t)
+	  && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
+	dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
+      if (DECL_ABSTRACT_ORIGIN (t))
+        dump_child ("orig", DECL_ABSTRACT_ORIGIN (t));
+      /* And types.  */
+      queue_and_dump_type (di, t);
+      dump_child ("scpe", DECL_CONTEXT (t));
+      /* And a source position.  */
+      xloc = expand_location (DECL_SOURCE_LOCATION (t));
+      if (xloc.file)
+	{
+	  const char *filename = lbasename (xloc.file);
+
+	  dump_maybe_newline (di);
+	  fprintf (di->stream, "srcp: %s:%-6d ", filename,
+		   xloc.line);
+	  di->column += 6 + strlen (filename) + 8;
+	}
+      /* And any declaration can be compiler-generated.  */
+      if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON)
+	  && DECL_ARTIFICIAL (t))
+	dump_string_field (di, "note", "artificial");
+      if (DECL_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
+	dump_child ("chain", DECL_CHAIN (t));
+    }
+  else if (code_class == tcc_type)
+    {
+      /* All types have qualifiers.  */
+      int quals = lang_hooks.tree_dump.type_quals (t);
+
+      if (quals != TYPE_UNQUALIFIED)
+	{
+	  fprintf (di->stream, "qual: %c%c%c     ",
+		   (quals & TYPE_QUAL_CONST) ? 'c' : ' ',
+		   (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
+		   (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
+	  di->column += 14;
+	}
+
+      /* All types have associated declarations.  */
+      dump_child ("name", TYPE_NAME (t));
+
+      /* All types have a main variant.  */
+      if (TYPE_MAIN_VARIANT (t) != t)
+	dump_child ("unql", TYPE_MAIN_VARIANT (t));
+
+      /* And sizes.  */
+      dump_child ("size", TYPE_SIZE (t));
+
+      /* All types have alignments.  */
+      dump_int (di, "algn", TYPE_ALIGN (t));
+    }
+  else if (code_class == tcc_constant)
+    /* All constants can have types.  */
+    queue_and_dump_type (di, t);
+
+  /* Give the language-specific code a chance to print something.  If
+     it's completely taken care of things, don't bother printing
+     anything more ourselves.  */
+  if (lang_hooks.tree_dump.dump_tree (di, t))
+    goto done;
+
+  /* Now handle the various kinds of nodes.  */
+  switch (code)
+    {
+      int i;
+
+    case IDENTIFIER_NODE:
+      dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
+      dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
+      break;
+
+    case TREE_LIST:
+      dump_child ("purp", TREE_PURPOSE (t));
+      dump_child ("valu", TREE_VALUE (t));
+      dump_child ("chan", TREE_CHAIN (t));
+      break;
+
+    case STATEMENT_LIST:
+      {
+	tree_stmt_iterator it;
+	for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
+	  {
+	    char buffer[32];
+	    sprintf (buffer, "%u", i);
+	    dump_child (buffer, tsi_stmt (it));
+	  }
+      }
+      break;
+
+    case TREE_VEC:
+      dump_int (di, "lngt", TREE_VEC_LENGTH (t));
+      for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
+	{
+	  char buffer[32];
+	  sprintf (buffer, "%u", i);
+	  dump_child (buffer, TREE_VEC_ELT (t, i));
+	}
+      break;
+
+    case INTEGER_TYPE:
+    case ENUMERAL_TYPE:
+      dump_int (di, "prec", TYPE_PRECISION (t));
+      dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
+      dump_child ("min", TYPE_MIN_VALUE (t));
+      dump_child ("max", TYPE_MAX_VALUE (t));
+
+      if (code == ENUMERAL_TYPE)
+	dump_child ("csts", TYPE_VALUES (t));
+      break;
+
+    case REAL_TYPE:
+      dump_int (di, "prec", TYPE_PRECISION (t));
+      break;
+
+    case FIXED_POINT_TYPE:
+      dump_int (di, "prec", TYPE_PRECISION (t));
+      dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
+      dump_string_field (di, "saturating",
+			 TYPE_SATURATING (t) ? "saturating": "non-saturating");
+      break;
+
+    case POINTER_TYPE:
+      dump_child ("ptd", TREE_TYPE (t));
+      break;
+
+    case REFERENCE_TYPE:
+      dump_child ("refd", TREE_TYPE (t));
+      break;
+
+    case METHOD_TYPE:
+      dump_child ("clas", TYPE_METHOD_BASETYPE (t));
+      /* Fall through.  */
+
+    case FUNCTION_TYPE:
+      dump_child ("retn", TREE_TYPE (t));
+      dump_child ("prms", TYPE_ARG_TYPES (t));
+      break;
+
+    case ARRAY_TYPE:
+      dump_child ("elts", TREE_TYPE (t));
+      dump_child ("domn", TYPE_DOMAIN (t));
+      break;
+
+    case RECORD_TYPE:
+    case UNION_TYPE:
+      if (TREE_CODE (t) == RECORD_TYPE)
+	dump_string_field (di, "tag", "struct");
+      else
+	dump_string_field (di, "tag", "union");
+
+      dump_child ("flds", TYPE_FIELDS (t));
+      dump_child ("fncs", TYPE_METHODS (t));
+      queue_and_dump_index (di, "binf", TYPE_BINFO (t),
+			    DUMP_BINFO);
+      break;
+
+    case CONST_DECL:
+      dump_child ("cnst", DECL_INITIAL (t));
+      break;
+
+    case DEBUG_EXPR_DECL:
+      dump_int (di, "-uid", DEBUG_TEMP_UID (t));
+      /* Fall through.  */
+
+    case VAR_DECL:
+    case PARM_DECL:
+    case FIELD_DECL:
+    case RESULT_DECL:
+      if (TREE_CODE (t) == PARM_DECL)
+	dump_child ("argt", DECL_ARG_TYPE (t));
+      else
+	dump_child ("init", DECL_INITIAL (t));
+      dump_child ("size", DECL_SIZE (t));
+      dump_int (di, "algn", DECL_ALIGN (t));
+
+      if (TREE_CODE (t) == FIELD_DECL)
+	{
+	  if (DECL_FIELD_OFFSET (t))
+	    dump_child ("bpos", bit_position (t));
+	}
+      else if (TREE_CODE (t) == VAR_DECL
+	       || TREE_CODE (t) == PARM_DECL)
+	{
+	  dump_int (di, "used", TREE_USED (t));
+	  if (DECL_REGISTER (t))
+	    dump_string_field (di, "spec", "register");
+	}
+      break;
+
+    case FUNCTION_DECL:
+      dump_child ("args", DECL_ARGUMENTS (t));
+      if (DECL_EXTERNAL (t))
+	dump_string_field (di, "body", "undefined");
+      if (TREE_PUBLIC (t))
+	dump_string_field (di, "link", "extern");
+      else
+	dump_string_field (di, "link", "static");
+      if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t))
+	dump_child ("body", DECL_SAVED_TREE (t));
+      break;
+
+    case INTEGER_CST:
+      if (TREE_INT_CST_HIGH (t))
+	dump_int (di, "high", TREE_INT_CST_HIGH (t));
+      dump_int (di, "low", TREE_INT_CST_LOW (t));
+      break;
+
+    case STRING_CST:
+      fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
+      dump_int (di, "lngt", TREE_STRING_LENGTH (t));
+      break;
+
+    case REAL_CST:
+      dump_real (di, "valu", TREE_REAL_CST_PTR (t));
+      break;
+
+    case FIXED_CST:
+      dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t));
+      break;
+
+    case TRUTH_NOT_EXPR:
+    case ADDR_EXPR:
+    case INDIRECT_REF:
+    case CLEANUP_POINT_EXPR:
+    case SAVE_EXPR:
+    case REALPART_EXPR:
+    case IMAGPART_EXPR:
+      /* These nodes are unary, but do not have code class `1'.  */
+      dump_child ("op 0", TREE_OPERAND (t, 0));
+      break;
+
+    case TRUTH_ANDIF_EXPR:
+    case TRUTH_ORIF_EXPR:
+    case INIT_EXPR:
+    case MODIFY_EXPR:
+    case COMPOUND_EXPR:
+    case PREDECREMENT_EXPR:
+    case PREINCREMENT_EXPR:
+    case POSTDECREMENT_EXPR:
+    case POSTINCREMENT_EXPR:
+      /* These nodes are binary, but do not have code class `2'.  */
+      dump_child ("op 0", TREE_OPERAND (t, 0));
+      dump_child ("op 1", TREE_OPERAND (t, 1));
+      break;
+
+    case COMPONENT_REF:
+    case BIT_FIELD_REF:
+      dump_child ("op 0", TREE_OPERAND (t, 0));
+      dump_child ("op 1", TREE_OPERAND (t, 1));
+      dump_child ("op 2", TREE_OPERAND (t, 2));
+      break;
+
+    case ARRAY_REF:
+    case ARRAY_RANGE_REF:
+      dump_child ("op 0", TREE_OPERAND (t, 0));
+      dump_child ("op 1", TREE_OPERAND (t, 1));
+      dump_child ("op 2", TREE_OPERAND (t, 2));
+      dump_child ("op 3", TREE_OPERAND (t, 3));
+      break;
+
+    case COND_EXPR:
+      dump_child ("op 0", TREE_OPERAND (t, 0));
+      dump_child ("op 1", TREE_OPERAND (t, 1));
+      dump_child ("op 2", TREE_OPERAND (t, 2));
+      break;
+
+    case TRY_FINALLY_EXPR:
+      dump_child ("op 0", TREE_OPERAND (t, 0));
+      dump_child ("op 1", TREE_OPERAND (t, 1));
+      break;
+
+    case CALL_EXPR:
+      {
+	int i = 0;
+	tree arg;
+	call_expr_arg_iterator iter;
+	dump_child ("fn", CALL_EXPR_FN (t));
+	FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
+	  {
+	    char buffer[32];
+	    sprintf (buffer, "%u", i);
+	    dump_child (buffer, arg);
+	    i++;
+	  }
+      }
+      break;
+
+    case CONSTRUCTOR:
+      {
+	unsigned HOST_WIDE_INT cnt;
+	tree index, value;
+	dump_int (di, "lngt", vec_safe_length (CONSTRUCTOR_ELTS (t)));
+	FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
+	  {
+	    dump_child ("idx", index);
+	    dump_child ("val", value);
+	  }
+      }
+      break;
+
+    case BIND_EXPR:
+      dump_child ("vars", TREE_OPERAND (t, 0));
+      dump_child ("body", TREE_OPERAND (t, 1));
+      break;
+
+    case LOOP_EXPR:
+      dump_child ("body", TREE_OPERAND (t, 0));
+      break;
+
+    case EXIT_EXPR:
+      dump_child ("cond", TREE_OPERAND (t, 0));
+      break;
+
+    case RETURN_EXPR:
+      dump_child ("expr", TREE_OPERAND (t, 0));
+      break;
+
+    case TARGET_EXPR:
+      dump_child ("decl", TREE_OPERAND (t, 0));
+      dump_child ("init", TREE_OPERAND (t, 1));
+      dump_child ("clnp", TREE_OPERAND (t, 2));
+      /* There really are two possible places the initializer can be.
+	 After RTL expansion, the second operand is moved to the
+	 position of the fourth operand, and the second operand
+	 becomes NULL.  */
+      dump_child ("init", TREE_OPERAND (t, 3));
+      break;
+
+    case CASE_LABEL_EXPR:
+      dump_child ("name", CASE_LABEL (t));
+      if (CASE_LOW (t))
+	{
+	  dump_child ("low ", CASE_LOW (t));
+	  if (CASE_HIGH (t))
+	    dump_child ("high", CASE_HIGH (t));
+	}
+      break;
+    case LABEL_EXPR:
+      dump_child ("name", TREE_OPERAND (t,0));
+      break;
+    case GOTO_EXPR:
+      dump_child ("labl", TREE_OPERAND (t, 0));
+      break;
+    case SWITCH_EXPR:
+      dump_child ("cond", TREE_OPERAND (t, 0));
+      dump_child ("body", TREE_OPERAND (t, 1));
+      if (TREE_OPERAND (t, 2))
+        {
+      	  dump_child ("labl", TREE_OPERAND (t,2));
+        }
+      break;
+    case OMP_CLAUSE:
+      {
+	int i;
+	fprintf (di->stream, "%s\n", omp_clause_code_name[OMP_CLAUSE_CODE (t)]);
+	for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++)
+	  dump_child ("op: ", OMP_CLAUSE_OPERAND (t, i));
+      }
+      break;
+    default:
+      /* There are no additional fields to print.  */
+      break;
+    }
+
+ done:
+  if (dump_flag (di, TDF_ADDRESS, NULL))
+    dump_pointer (di, "addr", (void *)t);
+
+  /* Terminate the line.  */
+  fprintf (di->stream, "\n");
+}
+
+/* Return nonzero if FLAG has been specified for the dump, and NODE
+   is not the root node of the dump.  */
+
+int dump_flag (dump_info_p di, int flag, const_tree node)
+{
+  return (di->flags & flag) && (node != di->node);
+}
+
+/* Dump T, and all its children, on STREAM.  */
+
+void
+dump_node (const_tree t, int flags, FILE *stream)
+{
+  struct dump_info di;
+  dump_queue_p dq;
+  dump_queue_p next_dq;
+
+  /* Initialize the dump-information structure.  */
+  di.stream = stream;
+  di.index = 0;
+  di.column = 0;
+  di.queue = 0;
+  di.queue_end = 0;
+  di.free_list = 0;
+  di.flags = flags;
+  di.node = t;
+  di.nodes = splay_tree_new (splay_tree_compare_pointers, 0,
+			     (splay_tree_delete_value_fn) &free);
+
+  /* Queue up the first node.  */
+  queue (&di, t, DUMP_NONE);
+
+  /* Until the queue is empty, keep dumping nodes.  */
+  while (di.queue)
+    dequeue_and_dump (&di);
+
+  /* Now, clean up.  */
+  for (dq = di.free_list; dq; dq = next_dq)
+    {
+      next_dq = dq->next;
+      free (dq);
+    }
+  splay_tree_delete (di.nodes);
+}