--- gcc/c-dump.c.orig	2005-06-25 04:02:01.000000000 +0200
+++ gcc/c-dump.c	2008-02-09 21:14:20.000000000 +0100
@@ -51,7 +51,7 @@
     {
     case FIELD_DECL:
       if (DECL_C_BIT_FIELD (t))
-	dump_string (di, "bitfield");
+	dump_string_field (di, "note", "bitfield");
       break;
 
     default:
--- gcc/tree-dump.c.orig	2007-11-12 18:39:43.000000000 +0100
+++ gcc/tree-dump.c	2008-06-29 20:14:04.000000000 +0200
@@ -32,6 +32,14 @@
 #include "tree-pass.h"
 #include "langhooks.h"
 #include "tree-iterator.h"
+#include "basic-block.h"
+#include "tree-flow.h"
+#include "real.h"
+
+//TODO prepsat na kontrolu flagu v di
+#define XML(di)     1
+#define INC_INDENT(di)    do { di->column += 2; if (di->column > 100) di->column = 20; } while (0);
+#define DEC_INDENT(di)    di->column = (di->column < 2) ? 50 : di->column-2;
 
 static unsigned int queue (dump_info_p, tree, int);
 static void dump_index (dump_info_p, unsigned int);
@@ -39,6 +47,7 @@
 static void dump_new_line (dump_info_p);
 static void dump_maybe_newline (dump_info_p);
 static int dump_enable_all (int, int);
+static void xml_fprints (FILE *, const char *);
 
 /* Add T to the end of the queue of nodes to dump.  Returns the index
    assigned to T.  */
@@ -113,9 +122,22 @@
 
   /* Print the index of the node.  */
   dump_maybe_newline (di);
-  fprintf (di->stream, "%-4s: ", field);
-  di->column += 6;
-  dump_index (di, index);
+  if (XML(di)) {
+    //if (n)
+      fprintf (di->stream, "<%s ref=\"%d\" />", field, index);
+    /*else {
+      fprintf (di->stream, "<%s ref=\"%d\">", field, index);
+      INC_INDENT(di);
+      dequeue_and_dump (di);
+      DEC_INDENT(di);
+      dump_maybe_newline (di);
+      fprintf (di->stream, "</%s>", field);
+    }*/
+  } else {
+    fprintf (di->stream, "%-4s: ", field);
+    di->column += 6;
+    dump_index (di, index);
+  }
 }
 
 /* Dump the type of T.  */
@@ -137,8 +159,12 @@
 static void
 dump_new_line (dump_info_p di)
 {
-  fprintf (di->stream, "\n%*s", SOL_COLUMN, "");
-  di->column = SOL_COLUMN;
+  if (XML(di))
+    fprintf (di->stream, "\n%*s", di->column, "");
+  else {
+    fprintf (di->stream, "\n%*s", SOL_COLUMN, "");
+    di->column = SOL_COLUMN;
+  }
 }
 
 /* If necessary, insert a new line.  */
@@ -149,7 +175,7 @@
   int extra;
 
   /* See if we need a new line.  */
-  if (di->column > EOL_COLUMN)
+  if (XML(di) || di->column > EOL_COLUMN)
     dump_new_line (di);
   /* See if we need any padding.  */
   else if ((extra = (di->column - SOL_COLUMN) % COLUMN_ALIGNMENT) != 0)
@@ -165,8 +191,12 @@
 dump_pointer (dump_info_p di, const char *field, void *ptr)
 {
   dump_maybe_newline (di);
-  fprintf (di->stream, "%-4s: %-8lx ", field, (long) ptr);
-  di->column += 15;
+  if (XML(di)) {
+    fprintf (di->stream, "<%s>%lx</%s>", field, (long) ptr, field);
+  } else {
+    fprintf (di->stream, "%-4s: %-8lx ", field, (long) ptr);
+    di->column += 15;
+  }
 }
 
 /* Dump integer I using FIELD to identify it.  */
@@ -175,21 +205,43 @@
 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;
+  if (XML(di)) {
+    fprintf (di->stream, "<%s>%d</%s>", field, i, field);
+  } else {
+    fprintf (di->stream, "%-4s: %-7d ", field, i);
+    di->column += 14;
+  }
 }
 
 /* Dump the string S.  */
-
+//TODO uplne vyhodit
 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;
+  if (XML(di)) {
+    xml_fprints (di->stream, string);
+  } else {
+    dump_maybe_newline (di);
+    fprintf (di->stream, "%-13s ", string);
+    if (strlen (string) > 13)
+      di->column += strlen (string) + 1;
+    else
+      di->column += 14;
+  }
+}
+
+
+static void
+xml_fprints (FILE *stream, const char *string)
+{
+  for ( ; *string; string++) {
+    switch (*string) {
+      case '<': fprintf(stream, "&lt;"); break;
+      case '>': fprintf(stream, "&gt;"); break;
+      case '&': fprintf(stream, "&amp;"); break;
+      default: fprintf(stream, "%c", *string); break;
+    }
+  }
 }
 
 /* Dump the string field S.  */
@@ -198,11 +250,129 @@
 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;
+  if (XML(di)) {
+    fprintf (di->stream, "<%s>", field);
+    xml_fprints(di->stream, string);
+    fprintf (di->stream, "</%s>", field);
+  } else {
+    fprintf (di->stream, "%-4s: %-7s ", field, string);
+    if (strlen (string) > 7)
+      di->column += 6 + strlen (string) + 1;
+    else
+      di->column += 14;
+  }
+}
+
+static void
+dump_bb_edge (dump_info_p di, edge e, int do_succ, struct function *f)
+{
+  basic_block side = (do_succ ? e->dest : e->src);
+
+  if (side == ENTRY_BLOCK_PTR_FOR_FUNCTION (f))
+    dump_string_field (di, "index", "entry");
+  else if (side == EXIT_BLOCK_PTR_FOR_FUNCTION (f))
+    dump_string_field (di, "index", "exit");
   else
-    di->column += 14;
+    dump_int (di, "index", side->index);
+
+  //if (e->probability)
+  //  fprintf (file, " [%.1f%%] ", e->probability * 100.0 / REG_BR_PROB_BASE);
+
+  /*if (e->count)
+    {
+      fprintf (file, " count:");
+      fprintf (file, HOST_WIDEST_INT_PRINT_DEC, e->count);
+    }*/
+
+  if (e->flags)
+    {
+      static const char * const bitnames[] = {
+	"fallthru", "ab", "abcall", "eh", "fake", "dfs_back",
+	"can_fallthru", "irreducible", "sibcall", "loop_exit",
+	"true", "false", "exec"
+      };
+      int i, flags = e->flags;
+
+      for (i = 0; flags; i++)
+	if (flags & (1 << i))
+	  {
+	    flags &= ~(1 << i);
+
+	    if (i < (int) ARRAY_SIZE (bitnames))
+	      dump_string_field (di, "flag", bitnames[i]);
+	    else
+	      dump_int (di, "flag", i);
+	  }
+    }
+}
+
+static void
+xml_start_section (dump_info_p di, const char *tag)
+{
+    dump_maybe_newline (di);
+    fprintf (di->stream, tag);
+    INC_INDENT(di);
+}
+
+static void
+xml_finish_section (dump_info_p di, const char *tag)
+{
+    DEC_INDENT(di);
+    dump_maybe_newline (di);
+    fprintf (di->stream, tag);
+}
+
+static void 
+dump_bb_node (dump_info_p di, basic_block bb, struct function *f)
+{
+    block_stmt_iterator bsi;
+    edge e;
+    edge_iterator ei;
+    int i = 0;
+    /* start basic block section */
+    xml_start_section (di, "<bb>");
+    /* index of the block */
+    dump_int (di, "index", bb->index);
+    /* dump block statements */
+    for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi), i++)
+    {
+	char buf[32];
+	sprintf (buf, "stm_%d", i);
+	queue_and_dump_index (di, buf, bsi_stmt (bsi), 0);
+    }
+#if 0
+    //TODO asi vyhodit, protoze to same se lepe da ziskat z vypisu pred/succ
+    //najdi hranu, ktera je primym pokracovanim
+    FOR_EACH_EDGE (e, ei, bb->succs)
+	if (e->flags & EDGE_FALLTHRU)
+	   break;
+    //a jejim cilem neni hned nasledujici blok
+    if (e && e->dest != bb->next_bb)
+    {
+	//pokud je prvni prikaz cile LABEL:
+	if (first_stmt (e->dest) && TREE_CODE (first_stmt (e->dest)) == LABEL_EXPR)
+	{
+	   queue_and_dump_index (di, "edge_goto", 
+	           first_stmt (e->dest), 0);
+	           //LABEL_EXPR_LABEL (first_stmt (e->dest)), 0);
+        }
+    }
+#endif
+    FOR_EACH_EDGE (e, ei, bb->preds) 
+    {
+        xml_start_section (di, "<pred>");
+        dump_bb_edge (di, e, 0, f);
+        xml_finish_section (di, "</pred>");
+    }
+    
+    FOR_EACH_EDGE (e, ei, bb->succs)
+    {
+        xml_start_section (di, "<succ>");
+        dump_bb_edge (di, e, 1, f);
+        xml_finish_section (di, "</succ>");
+    }
+    /* finish section */
+    xml_finish_section (di, "</bb>");
 }
 
 /* Dump the next node in the queue.  */
@@ -233,15 +403,23 @@
   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 = tree_code_name[(int) TREE_CODE (t)];
-  fprintf (di->stream, "%-16s ", code_name);
-  di->column = 25;
+
+  if (XML(di)) {
+    /* Print the node type and index */
+    dump_maybe_newline (di);
+    fprintf (di->stream, "<%s id=\"%d\">", code_name, index);
+    INC_INDENT(di);
+  } else {
+    /* Print the node index.  */
+    dump_index (di, index);
+    /* And the type of node this is.  */
+    fprintf (di->stream, "%-16s ", code_name);
+    di->column = 25;
+  }
 
   /* Figure out what kind of node this is.  */
   code = TREE_CODE (t);
@@ -276,8 +454,19 @@
 	  else
 	    gcc_unreachable ();
 
-	  dump_string_field (di, "accs", string);
-	  queue_and_dump_index (di, "binf", base, DUMP_BINFO);
+	  if (XML (di))
+	    {
+	      char buf[32];
+	      sprintf (buf, "accs_%d", ix);
+	      dump_string_field (di, buf, string);
+	      sprintf (buf, "binf_%d", ix);
+	      queue_and_dump_index (di, buf, base, DUMP_BINFO);
+	    }
+	  else
+	    {
+	      dump_string_field (di, "accs", string);
+	      queue_and_dump_index (di, "binf", base, DUMP_BINFO);
+	    }
 	}
 
       goto done;
@@ -293,13 +482,13 @@
       switch (code_class)
 	{
 	case tcc_unary:
-	  dump_child ("op 0", TREE_OPERAND (t, 0));
+	  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));
+	  dump_child ("op_0", TREE_OPERAND (t, 0));
+	  dump_child ("op_1", TREE_OPERAND (t, 1));
 	  break;
 
 	case tcc_expression:
@@ -338,9 +527,21 @@
 	    ++filename;
 
 	  dump_maybe_newline (di);
-	  fprintf (di->stream, "srcp: %s:%-6d ", filename,
+	  if (XML(di)) {
+	    if (strcmp(filename, "<built-in>")) {
+	      /* not a built-in */
+	      fprintf (di->stream, "<srcp line=\"%d\">", xloc.line);
+	      xml_fprints (di->stream, filename);
+	      fprintf (di->stream, "</srcp>");
+	    } else {
+	      /* Built-in */
+	      fprintf (di->stream, "<builtin />");
+	    }
+	  } else {
+            fprintf (di->stream, "srcp: %s:%-6d ", filename,
 		   xloc.line);
-	  di->column += 6 + strlen (filename) + 8;
+	    di->column += 6 + strlen (filename) + 8;
+	  }
 	}
       /* And any declaration can be compiler-generated.  */
       if (DECL_ARTIFICIAL (t))
@@ -355,15 +556,23 @@
 
       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;
+	  if (XML(di)) {
+            dump_maybe_newline (di);
+	    fprintf (di->stream, "<qual>%c%c%c</qual>",
+		      (quals & TYPE_QUAL_CONST) ? 'c' : ' ',
+		      (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
+		      (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
+	  } else {
+	    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));
+      dump_child ("tname", TYPE_NAME (t));
 
       /* All types have a main variant.  */
       if (TYPE_MAIN_VARIANT (t) != t)
@@ -407,7 +616,10 @@
 	for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
 	  {
 	    char buffer[32];
-	    sprintf (buffer, "%u", i);
+	    if (XML(di))
+	      sprintf (buffer, "itm_%u", i);
+	    else
+	      sprintf (buffer, "%u", i);
 	    dump_child (buffer, tsi_stmt (it));
 	  }
       }
@@ -418,7 +630,10 @@
       for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
 	{
 	  char buffer[32];
-	  sprintf (buffer, "%u", i);
+	  if (XML(di))
+	    sprintf (buffer, "itm_%u", i);
+	  else
+	    sprintf (buffer, "%u", i);
 	  dump_child (buffer, TREE_VEC_ELT (t, i));
 	}
       break;
@@ -446,6 +661,12 @@
       dump_child ("refd", TREE_TYPE (t));
       break;
 
+    case OBJ_TYPE_REF:
+      dump_child ("expr", TREE_OPERAND (t, 0));
+      dump_child ("obj", TREE_OPERAND (t, 1));
+      dump_child ("tokn", TREE_OPERAND (t, 2));
+      break;
+
     case METHOD_TYPE:
       dump_child ("clas", TYPE_METHOD_BASETYPE (t));
       /* Fall through.  */
@@ -510,8 +731,32 @@
 	dump_string_field (di, "link", "extern");
       else
 	dump_string_field (di, "link", "static");
-      if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
-	dump_child ("body", DECL_SAVED_TREE (t));
+      /*if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
+	dump_child ("body", DECL_SAVED_TREE (t));*/
+      if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t)) {
+        struct function *f = DECL_STRUCT_FUNCTION(t);
+        if (XML(di) && f && f->cfg) {
+          basic_block bb;
+          tree vars, var;
+          /* start control flow graph section */
+          xml_start_section (di, "<cfg>");
+          /* dump variables */
+	  for (vars = f->unexpanded_var_list; vars; vars = TREE_CHAIN (vars))
+	  {
+	    var = TREE_VALUE (vars);
+	    queue_and_dump_index (di, "var", var, 0);
+	  }
+	  /* dump basic blocks */
+          FOR_EACH_BB_FN (bb, f) {
+	    dump_bb_node (di, bb, f);
+          }
+          /* finish section */
+          xml_finish_section (di, "</cfg>");
+        } else {
+	  //FIXME temporary disabled
+          //dump_child ("body", DECL_SAVED_TREE (t));
+	}
+      }
       break;
 
     case INTEGER_CST:
@@ -521,10 +766,24 @@
       break;
 
     case STRING_CST:
-      fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
+      if (XML(di)) {
+        dump_maybe_newline (di);
+        fprintf (di->stream, "<strg>");
+        xml_fprints (di->stream, TREE_STRING_POINTER (t));
+        fprintf (di->stream, "</strg>");
+      } else
+        fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
       dump_int (di, "lngt", TREE_STRING_LENGTH (t));
       break;
 
+    case REAL_CST:
+      {
+        char rval[128];
+        real_to_decimal (rval, TREE_REAL_CST_PTR (t), 128, 0, true);
+        dump_string_field (di, "rval", rval);
+        break;
+      }
+
     case TRUTH_NOT_EXPR:
     case ADDR_EXPR:
     case INDIRECT_REF:
@@ -535,7 +794,7 @@
     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));
+      dump_child ("op_0", TREE_OPERAND (t, 0));
       break;
 
     case TRUTH_ANDIF_EXPR:
@@ -548,33 +807,40 @@
     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));
+      dump_child ("op_0", TREE_OPERAND (t, 0));
+      dump_child ("op_1", TREE_OPERAND (t, 1));
       break;
 
     case COMPONENT_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_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));
+      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 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));
+      dump_int (di, "unsig", BIT_FIELD_REF_UNSIGNED (t));
       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));
+      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));
+      dump_child ("op_0", TREE_OPERAND (t, 0));
+      dump_child ("op_1", TREE_OPERAND (t, 1));
       break;
 
     case CALL_EXPR:
@@ -586,12 +852,24 @@
       {
 	unsigned HOST_WIDE_INT cnt;
 	tree index, value;
+	dump_child ("type", TREE_TYPE (t));
 	dump_int (di, "lngt", VEC_length (constructor_elt,
 					  CONSTRUCTOR_ELTS (t)));
 	FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
 	  {
-	    dump_child ("idx", index);
-	    dump_child ("val", value);
+	    if (XML (di))
+	      {
+	        char buf[32];
+	        sprintf (buf, "idx_%lu", cnt);
+	        dump_child (buf, index);
+	        sprintf (buf, "val_%lu", cnt);
+	        dump_child (buf, value);
+	      }
+	    else
+	      {
+		dump_child ("idx", index);
+		dump_child ("val", value);
+	      }
 	  }
       }
       break;
@@ -625,16 +903,16 @@
       break;
 
     case CASE_LABEL_EXPR:
-      dump_child ("name", CASE_LABEL (t));
+      dump_child ("lname", CASE_LABEL (t));
       if (CASE_LOW (t)) {
-        dump_child ("low ", CASE_LOW (t));
+        dump_child ("vlow ", CASE_LOW (t));
 	if (CASE_HIGH (t)) {
-	  dump_child ("high", CASE_HIGH (t));
+	  dump_child ("vhigh", CASE_HIGH (t));
 	}
       }
       break;
     case LABEL_EXPR:
-      dump_child ("name", TREE_OPERAND (t,0));
+      dump_child ("lname", TREE_OPERAND (t,0));
       break;
     case GOTO_EXPR:
       dump_child ("labl", TREE_OPERAND (t, 0));
@@ -656,8 +934,15 @@
   if (dump_flag (di, TDF_ADDRESS, NULL))
     dump_pointer (di, "addr", (void *)t);
 
-  /* Terminate the line.  */
-  fprintf (di->stream, "\n");
+  if (XML(di)) {
+    /* Terminate the tag. */
+    DEC_INDENT(di);
+    dump_maybe_newline (di);
+    fprintf (di->stream, "</%s>", code_name);
+  } else {
+    /* Terminate the line.  */
+    fprintf (di->stream, "\n");
+  }
 }
 
 /* Return nonzero if FLAG has been specified for the dump, and NODE
@@ -692,10 +977,18 @@
   /* Queue up the first node.  */
   queue (&di, t, DUMP_NONE);
 
+  if (XML(di)) {
+    fprintf (di.stream, "<tree>\n");
+  }
+
   /* Until the queue is empty, keep dumping nodes.  */
   while (di.queue)
     dequeue_and_dump (&di);
 
+  if (XML(di)) {
+    fprintf (di.stream, "\n</tree>\n");
+  }
+
   /* Now, clean up.  */
   for (dq = di.free_list; dq; dq = next_dq)
     {
--- gcc/cp/dump.c.orig	2005-07-03 08:50:51.000000000 +0200
+++ gcc/cp/dump.c	2008-05-02 20:15:23.000000000 +0200
@@ -30,7 +30,7 @@
 
 static void dump_access (dump_info_p, tree);
 
-static void dump_op (dump_info_p, tree);
+static char *dump_op (dump_info_p, tree);
 
 /* Dump a representation of the accessibility information associated
    with T.  */
@@ -49,158 +49,159 @@
 /* Dump a representation of the specific operator for an overloaded
    operator associated with node t.  */
 
-static void
+static char*
 dump_op (dump_info_p di, tree t)
 {
   switch (DECL_OVERLOADED_OPERATOR_P (t)) {
     case NEW_EXPR:
-      dump_string (di, "new");
+      return "new";
       break;
     case VEC_NEW_EXPR:
-      dump_string (di, "vecnew");
+      return "vecnew";
       break;
     case DELETE_EXPR:
-      dump_string (di, "delete");
+      return "delete";
       break;
     case VEC_DELETE_EXPR:
-      dump_string (di, "vecdelete");
+      return "vecdelete";
       break;
     case UNARY_PLUS_EXPR:
-      dump_string (di, "pos");
+      return "pos";
       break;
     case NEGATE_EXPR:
-      dump_string (di, "neg");
+      return "neg";
       break;
     case ADDR_EXPR:
-      dump_string (di, "addr");
+      return "addr";
       break;
     case INDIRECT_REF:
-      dump_string(di, "deref");
+      return "deref";
       break;
     case BIT_NOT_EXPR:
-      dump_string(di, "not");
+      return "not";
       break;
     case TRUTH_NOT_EXPR:
-      dump_string(di, "lnot");
+      return "lnot";
       break;
     case PREINCREMENT_EXPR:
-      dump_string(di, "preinc");
+      return "preinc";
       break;
     case PREDECREMENT_EXPR:
-      dump_string(di, "predec");
+      return "predec";
       break;
     case PLUS_EXPR:
       if (DECL_ASSIGNMENT_OPERATOR_P (t))
-	dump_string (di, "plusassign");
+	return "plusassign";
       else
-	dump_string(di, "plus");
+	return "plus";
       break;
     case MINUS_EXPR:
       if (DECL_ASSIGNMENT_OPERATOR_P (t))
-	dump_string (di, "minusassign");
+	return "minusassign";
       else
-	dump_string(di, "minus");
+	return "minus";
       break;
     case MULT_EXPR:
       if (DECL_ASSIGNMENT_OPERATOR_P (t))
-	dump_string (di, "multassign");
+	return "multassign";
       else
-	dump_string (di, "mult");
+	return "mult";
       break;
     case TRUNC_DIV_EXPR:
       if (DECL_ASSIGNMENT_OPERATOR_P (t))
-	dump_string (di, "divassign");
+	return "divassign";
       else
-	dump_string (di, "div");
+	return "div";
       break;
     case TRUNC_MOD_EXPR:
       if (DECL_ASSIGNMENT_OPERATOR_P (t))
-	 dump_string (di, "modassign");
+	 return "modassign";
       else
-	dump_string (di, "mod");
+	return "mod";
       break;
     case BIT_AND_EXPR:
       if (DECL_ASSIGNMENT_OPERATOR_P (t))
-	dump_string (di, "andassign");
+	return "andassign";
       else
-	dump_string (di, "and");
+	return "and";
       break;
     case BIT_IOR_EXPR:
       if (DECL_ASSIGNMENT_OPERATOR_P (t))
-	dump_string (di, "orassign");
+	return "orassign";
       else
-	dump_string (di, "or");
+	return "or";
       break;
     case BIT_XOR_EXPR:
       if (DECL_ASSIGNMENT_OPERATOR_P (t))
-	dump_string (di, "xorassign");
+	return "xorassign";
       else
-	dump_string (di, "xor");
+	return "xor";
       break;
     case LSHIFT_EXPR:
       if (DECL_ASSIGNMENT_OPERATOR_P (t))
-	dump_string (di, "lshiftassign");
+	return "lshiftassign";
       else
-	dump_string (di, "lshift");
+	return "lshift";
       break;
     case RSHIFT_EXPR:
       if (DECL_ASSIGNMENT_OPERATOR_P (t))
-	dump_string (di, "rshiftassign");
+	return "rshiftassign";
       else
-	dump_string (di, "rshift");
+	return "rshift";
       break;
     case EQ_EXPR:
-      dump_string (di, "eq");
+      return "eq";
       break;
     case NE_EXPR:
-      dump_string (di, "ne");
+      return "ne";
       break;
     case LT_EXPR:
-      dump_string (di, "lt");
+      return "lt";
       break;
     case GT_EXPR:
-      dump_string (di, "gt");
+      return "gt";
       break;
     case LE_EXPR:
-      dump_string (di, "le");
+      return "le";
       break;
     case GE_EXPR:
-      dump_string (di, "ge");
+      return "ge";
       break;
     case TRUTH_ANDIF_EXPR:
-      dump_string (di, "land");
+      return "land";
       break;
     case TRUTH_ORIF_EXPR:
-      dump_string (di, "lor");
+      return "lor";
       break;
     case COMPOUND_EXPR:
-      dump_string (di, "compound");
+      return "compound";
       break;
     case MEMBER_REF:
-      dump_string (di, "memref");
+      return "memref";
       break;
     case COMPONENT_REF:
-      dump_string (di, "ref");
+      return "ref";
       break;
     case ARRAY_REF:
-      dump_string (di, "subs");
+      return "subs";
       break;
     case POSTINCREMENT_EXPR:
-      dump_string (di, "postinc");
+      return "postinc";
       break;
     case POSTDECREMENT_EXPR:
-      dump_string (di, "postdec");
+      return "postdec";
       break;
     case CALL_EXPR:
-      dump_string (di, "call");
+      return "call";
       break;
     case NOP_EXPR:
       if (DECL_ASSIGNMENT_OPERATOR_P (t))
-	dump_string (di, "assign");
+	return "assign";
       break;
     default:
       break;
   }
+  return "";
 }
 
 bool
@@ -263,7 +264,7 @@
 
       dump_child ("vfld", TYPE_VFIELD (t));
       if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t))
-	dump_string(di, "spec");
+	dump_string_field(di, "note", "templ_spec");
 
       if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t))
 	{
@@ -299,8 +300,7 @@
       if (!DECL_THUNK_P (t))
 	{
 	  if (DECL_OVERLOADED_OPERATOR_P (t)) {
-	    dump_string_field (di, "note", "operator");
-	    dump_op (di, t);
+	    dump_string_field (di, "note_operator", dump_op (di, t));
 	  }
 	  if (DECL_FUNCTION_MEMBER_P (t))
 	    {
@@ -358,6 +358,14 @@
       dump_child ("prms", DECL_TEMPLATE_PARMS (t));
       break;
 
+    case TEMPLATE_PARM_INDEX:
+      dump_int (di, "index", TEMPLATE_PARM_IDX (t));
+      dump_int (di, "level", TEMPLATE_PARM_LEVEL (t));
+      dump_int (di, "orig_level", TEMPLATE_PARM_ORIG_LEVEL (t));
+      dump_child ("decl", TEMPLATE_PARM_DECL (t));
+      //dump_child ("type", TREE_TYPE (t));
+      break;
+
     case OVERLOAD:
       dump_child ("crnt", OVL_CURRENT (t));
       dump_child ("chan", OVL_CHAIN (t));
@@ -384,7 +392,7 @@
 
     case THROW_EXPR:
       /* These nodes are unary, but do not have code class `1'.  */
-      dump_child ("op 0", TREE_OPERAND (t, 0));
+      dump_child ("op_0", TREE_OPERAND (t, 0));
       break;
 
     case AGGR_INIT_EXPR:
@@ -464,6 +472,11 @@
       dump_child ("expr", EXPR_STMT_EXPR (t));
       break;
 
+    case SCOPE_REF:
+      dump_child ("clas", TREE_OPERAND (t, 0));
+      dump_child ("fld", TREE_OPERAND (t, 1));
+      break;
+
     default:
       break;
     }