OSDN Git Service

2008-05-16 Kenneth Zadeck <zadeck@naturalbridge.com>
[pf3gnuchains/gcc-fork.git] / gcc / tree-dump.c
1 /* Tree-dumping functionality for intermediate representation.
2    Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008
3    Free Software Foundation, Inc.
4    Written by Mark Mitchell <mark@codesourcery.com>
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "tree.h"
27 #include "splay-tree.h"
28 #include "diagnostic.h"
29 #include "toplev.h"
30 #include "tree-dump.h"
31 #include "tree-pass.h"
32 #include "langhooks.h"
33 #include "tree-iterator.h"
34 #include "real.h"
35 #include "fixed-value.h"
36
37 static unsigned int queue (dump_info_p, const_tree, int);
38 static void dump_index (dump_info_p, unsigned int);
39 static void dequeue_and_dump (dump_info_p);
40 static void dump_new_line (dump_info_p);
41 static void dump_maybe_newline (dump_info_p);
42
43 /* Add T to the end of the queue of nodes to dump.  Returns the index
44    assigned to T.  */
45
46 static unsigned int
47 queue (dump_info_p di, const_tree t, int flags)
48 {
49   dump_queue_p dq;
50   dump_node_info_p dni;
51   unsigned int index;
52
53   /* Assign the next available index to T.  */
54   index = ++di->index;
55
56   /* Obtain a new queue node.  */
57   if (di->free_list)
58     {
59       dq = di->free_list;
60       di->free_list = dq->next;
61     }
62   else
63     dq = XNEW (struct dump_queue);
64
65   /* Create a new entry in the splay-tree.  */
66   dni = XNEW (struct dump_node_info);
67   dni->index = index;
68   dni->binfo_p = ((flags & DUMP_BINFO) != 0);
69   dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t,
70                                 (splay_tree_value) dni);
71
72   /* Add it to the end of the queue.  */
73   dq->next = 0;
74   if (!di->queue_end)
75     di->queue = dq;
76   else
77     di->queue_end->next = dq;
78   di->queue_end = dq;
79
80   /* Return the index.  */
81   return index;
82 }
83
84 static void
85 dump_index (dump_info_p di, unsigned int index)
86 {
87   fprintf (di->stream, "@%-6u ", index);
88   di->column += 8;
89 }
90
91 /* If T has not already been output, queue it for subsequent output.
92    FIELD is a string to print before printing the index.  Then, the
93    index of T is printed.  */
94
95 void
96 queue_and_dump_index (dump_info_p di, const char *field, const_tree t, int flags)
97 {
98   unsigned int index;
99   splay_tree_node n;
100
101   /* If there's no node, just return.  This makes for fewer checks in
102      our callers.  */
103   if (!t)
104     return;
105
106   /* See if we've already queued or dumped this node.  */
107   n = splay_tree_lookup (di->nodes, (splay_tree_key) t);
108   if (n)
109     index = ((dump_node_info_p) n->value)->index;
110   else
111     /* If we haven't, add it to the queue.  */
112     index = queue (di, t, flags);
113
114   /* Print the index of the node.  */
115   dump_maybe_newline (di);
116   fprintf (di->stream, "%-4s: ", field);
117   di->column += 6;
118   dump_index (di, index);
119 }
120
121 /* Dump the type of T.  */
122
123 void
124 queue_and_dump_type (dump_info_p di, const_tree t)
125 {
126   queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
127 }
128
129 /* Dump column control */
130 #define SOL_COLUMN 25           /* Start of line column.  */
131 #define EOL_COLUMN 55           /* End of line column.  */
132 #define COLUMN_ALIGNMENT 15     /* Alignment.  */
133
134 /* Insert a new line in the dump output, and indent to an appropriate
135    place to start printing more fields.  */
136
137 static void
138 dump_new_line (dump_info_p di)
139 {
140   fprintf (di->stream, "\n%*s", SOL_COLUMN, "");
141   di->column = SOL_COLUMN;
142 }
143
144 /* If necessary, insert a new line.  */
145
146 static void
147 dump_maybe_newline (dump_info_p di)
148 {
149   int extra;
150
151   /* See if we need a new line.  */
152   if (di->column > EOL_COLUMN)
153     dump_new_line (di);
154   /* See if we need any padding.  */
155   else if ((extra = (di->column - SOL_COLUMN) % COLUMN_ALIGNMENT) != 0)
156     {
157       fprintf (di->stream, "%*s", COLUMN_ALIGNMENT - extra, "");
158       di->column += COLUMN_ALIGNMENT - extra;
159     }
160 }
161
162 /* Dump pointer PTR using FIELD to identify it.  */
163
164 void
165 dump_pointer (dump_info_p di, const char *field, void *ptr)
166 {
167   dump_maybe_newline (di);
168   fprintf (di->stream, "%-4s: %-8lx ", field, (unsigned long) ptr);
169   di->column += 15;
170 }
171
172 /* Dump integer I using FIELD to identify it.  */
173
174 void
175 dump_int (dump_info_p di, const char *field, int i)
176 {
177   dump_maybe_newline (di);
178   fprintf (di->stream, "%-4s: %-7d ", field, i);
179   di->column += 14;
180 }
181
182 /* Dump the floating point value R, using FIELD to identify it.  */
183
184 static void
185 dump_real (dump_info_p di, const char *field, const REAL_VALUE_TYPE *r)
186 {
187   char buf[32];
188   real_to_decimal (buf, r, sizeof (buf), 0, true);
189   dump_maybe_newline (di);
190   fprintf (di->stream, "%-4s: %s ", field, buf);
191   di->column += strlen (buf) + 7;
192 }
193
194 /* Dump the fixed-point value F, using FIELD to identify it.  */
195
196 static void
197 dump_fixed (dump_info_p di, const char *field, const FIXED_VALUE_TYPE *f)
198 {
199   char buf[32];
200   fixed_to_decimal (buf, f, sizeof (buf));
201   dump_maybe_newline (di);
202   fprintf (di->stream, "%-4s: %s ", field, buf);
203   di->column += strlen (buf) + 7;
204 }
205
206
207 /* Dump the string S.  */
208
209 void
210 dump_string (dump_info_p di, const char *string)
211 {
212   dump_maybe_newline (di);
213   fprintf (di->stream, "%-13s ", string);
214   if (strlen (string) > 13)
215     di->column += strlen (string) + 1;
216   else
217     di->column += 14;
218 }
219
220 /* Dump the string field S.  */
221
222 void
223 dump_string_field (dump_info_p di, const char *field, const char *string)
224 {
225   dump_maybe_newline (di);
226   fprintf (di->stream, "%-4s: %-7s ", field, string);
227   if (strlen (string) > 7)
228     di->column += 6 + strlen (string) + 1;
229   else
230     di->column += 14;
231 }
232
233 /* Dump the next node in the queue.  */
234
235 static void
236 dequeue_and_dump (dump_info_p di)
237 {
238   dump_queue_p dq;
239   splay_tree_node stn;
240   dump_node_info_p dni;
241   tree t;
242   unsigned int index;
243   enum tree_code code;
244   enum tree_code_class code_class;
245   const char* code_name;
246
247   /* Get the next node from the queue.  */
248   dq = di->queue;
249   stn = dq->node;
250   t = (tree) stn->key;
251   dni = (dump_node_info_p) stn->value;
252   index = dni->index;
253
254   /* Remove the node from the queue, and put it on the free list.  */
255   di->queue = dq->next;
256   if (!di->queue)
257     di->queue_end = 0;
258   dq->next = di->free_list;
259   di->free_list = dq;
260
261   /* Print the node index.  */
262   dump_index (di, index);
263   /* And the type of node this is.  */
264   if (dni->binfo_p)
265     code_name = "binfo";
266   else
267     code_name = tree_code_name[(int) TREE_CODE (t)];
268   fprintf (di->stream, "%-16s ", code_name);
269   di->column = 25;
270
271   /* Figure out what kind of node this is.  */
272   code = TREE_CODE (t);
273   code_class = TREE_CODE_CLASS (code);
274
275   /* Although BINFOs are TREE_VECs, we dump them specially so as to be
276      more informative.  */
277   if (dni->binfo_p)
278     {
279       unsigned ix;
280       tree base;
281       VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (t);
282
283       dump_child ("type", BINFO_TYPE (t));
284
285       if (BINFO_VIRTUAL_P (t))
286         dump_string_field (di, "spec", "virt");
287
288       dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
289       for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)
290         {
291           tree access = (accesses ? VEC_index (tree, accesses, ix)
292                          : access_public_node);
293           const char *string = NULL;
294
295           if (access == access_public_node)
296             string = "pub";
297           else if (access == access_protected_node)
298             string = "prot";
299           else if (access == access_private_node)
300             string = "priv";
301           else
302             gcc_unreachable ();
303
304           dump_string_field (di, "accs", string);
305           queue_and_dump_index (di, "binf", base, DUMP_BINFO);
306         }
307
308       goto done;
309     }
310
311   /* We can knock off a bunch of expression nodes in exactly the same
312      way.  */
313   if (IS_EXPR_CODE_CLASS (code_class))
314     {
315       /* If we're dumping children, dump them now.  */
316       queue_and_dump_type (di, t);
317
318       switch (code_class)
319         {
320         case tcc_unary:
321           dump_child ("op 0", TREE_OPERAND (t, 0));
322           break;
323
324         case tcc_binary:
325         case tcc_comparison:
326           dump_child ("op 0", TREE_OPERAND (t, 0));
327           dump_child ("op 1", TREE_OPERAND (t, 1));
328           break;
329
330         case tcc_expression:
331         case tcc_reference:
332         case tcc_statement:
333         case tcc_vl_exp:
334           /* These nodes are handled explicitly below.  */
335           break;
336
337         default:
338           gcc_unreachable ();
339         }
340     }
341   else if (DECL_P (t))
342     {
343       expanded_location xloc;
344       /* All declarations have names.  */
345       if (DECL_NAME (t))
346         dump_child ("name", DECL_NAME (t));
347       if (DECL_ASSEMBLER_NAME_SET_P (t)
348           && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
349         dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
350       if (DECL_ABSTRACT_ORIGIN (t))
351         dump_child ("orig", DECL_ABSTRACT_ORIGIN (t));
352       /* And types.  */
353       queue_and_dump_type (di, t);
354       dump_child ("scpe", DECL_CONTEXT (t));
355       /* And a source position.  */
356       xloc = expand_location (DECL_SOURCE_LOCATION (t));
357       if (xloc.file)
358         {
359           const char *filename = strrchr (xloc.file, '/');
360           if (!filename)
361             filename = xloc.file;
362           else
363             /* Skip the slash.  */
364             ++filename;
365
366           dump_maybe_newline (di);
367           fprintf (di->stream, "srcp: %s:%-6d ", filename,
368                    xloc.line);
369           di->column += 6 + strlen (filename) + 8;
370         }
371       /* And any declaration can be compiler-generated.  */
372       if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON)
373           && DECL_ARTIFICIAL (t))
374         dump_string_field (di, "note", "artificial");
375       if (TREE_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
376         dump_child ("chan", TREE_CHAIN (t));
377     }
378   else if (code_class == tcc_type)
379     {
380       /* All types have qualifiers.  */
381       int quals = lang_hooks.tree_dump.type_quals (t);
382
383       if (quals != TYPE_UNQUALIFIED)
384         {
385           fprintf (di->stream, "qual: %c%c%c     ",
386                    (quals & TYPE_QUAL_CONST) ? 'c' : ' ',
387                    (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
388                    (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
389           di->column += 14;
390         }
391
392       /* All types have associated declarations.  */
393       dump_child ("name", TYPE_NAME (t));
394
395       /* All types have a main variant.  */
396       if (TYPE_MAIN_VARIANT (t) != t)
397         dump_child ("unql", TYPE_MAIN_VARIANT (t));
398
399       /* And sizes.  */
400       dump_child ("size", TYPE_SIZE (t));
401
402       /* All types have alignments.  */
403       dump_int (di, "algn", TYPE_ALIGN (t));
404     }
405   else if (code_class == tcc_constant)
406     /* All constants can have types.  */
407     queue_and_dump_type (di, t);
408
409   /* Give the language-specific code a chance to print something.  If
410      it's completely taken care of things, don't bother printing
411      anything more ourselves.  */
412   if (lang_hooks.tree_dump.dump_tree (di, t))
413     goto done;
414
415   /* Now handle the various kinds of nodes.  */
416   switch (code)
417     {
418       int i;
419
420     case IDENTIFIER_NODE:
421       dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
422       dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
423       break;
424
425     case TREE_LIST:
426       dump_child ("purp", TREE_PURPOSE (t));
427       dump_child ("valu", TREE_VALUE (t));
428       dump_child ("chan", TREE_CHAIN (t));
429       break;
430
431     case STATEMENT_LIST:
432       {
433         tree_stmt_iterator it;
434         for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
435           {
436             char buffer[32];
437             sprintf (buffer, "%u", i);
438             dump_child (buffer, tsi_stmt (it));
439           }
440       }
441       break;
442
443     case TREE_VEC:
444       dump_int (di, "lngt", TREE_VEC_LENGTH (t));
445       for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
446         {
447           char buffer[32];
448           sprintf (buffer, "%u", i);
449           dump_child (buffer, TREE_VEC_ELT (t, i));
450         }
451       break;
452
453     case INTEGER_TYPE:
454     case ENUMERAL_TYPE:
455       dump_int (di, "prec", TYPE_PRECISION (t));
456       dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
457       dump_child ("min", TYPE_MIN_VALUE (t));
458       dump_child ("max", TYPE_MAX_VALUE (t));
459
460       if (code == ENUMERAL_TYPE)
461         dump_child ("csts", TYPE_VALUES (t));
462       break;
463
464     case REAL_TYPE:
465       dump_int (di, "prec", TYPE_PRECISION (t));
466       break;
467
468     case FIXED_POINT_TYPE:
469       dump_int (di, "prec", TYPE_PRECISION (t));
470       dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
471       dump_string_field (di, "saturating",
472                          TYPE_SATURATING (t) ? "saturating": "non-saturating");
473       break;
474
475     case POINTER_TYPE:
476       dump_child ("ptd", TREE_TYPE (t));
477       break;
478
479     case REFERENCE_TYPE:
480       dump_child ("refd", TREE_TYPE (t));
481       break;
482
483     case METHOD_TYPE:
484       dump_child ("clas", TYPE_METHOD_BASETYPE (t));
485       /* Fall through.  */
486
487     case FUNCTION_TYPE:
488       dump_child ("retn", TREE_TYPE (t));
489       dump_child ("prms", TYPE_ARG_TYPES (t));
490       break;
491
492     case ARRAY_TYPE:
493       dump_child ("elts", TREE_TYPE (t));
494       dump_child ("domn", TYPE_DOMAIN (t));
495       break;
496
497     case RECORD_TYPE:
498     case UNION_TYPE:
499       if (TREE_CODE (t) == RECORD_TYPE)
500         dump_string_field (di, "tag", "struct");
501       else
502         dump_string_field (di, "tag", "union");
503
504       dump_child ("flds", TYPE_FIELDS (t));
505       dump_child ("fncs", TYPE_METHODS (t));
506       queue_and_dump_index (di, "binf", TYPE_BINFO (t),
507                             DUMP_BINFO);
508       break;
509
510     case CONST_DECL:
511       dump_child ("cnst", DECL_INITIAL (t));
512       break;
513       
514     case SYMBOL_MEMORY_TAG:
515     case NAME_MEMORY_TAG:
516       break;
517
518     case VAR_DECL:
519     case PARM_DECL:
520     case FIELD_DECL:
521     case RESULT_DECL:
522       if (TREE_CODE (t) == PARM_DECL)
523         dump_child ("argt", DECL_ARG_TYPE (t));
524       else
525         dump_child ("init", DECL_INITIAL (t));
526       dump_child ("size", DECL_SIZE (t));
527       dump_int (di, "algn", DECL_ALIGN (t));
528
529       if (TREE_CODE (t) == FIELD_DECL)
530         {
531           if (DECL_FIELD_OFFSET (t))
532             dump_child ("bpos", bit_position (t));
533         }
534       else if (TREE_CODE (t) == VAR_DECL
535                || TREE_CODE (t) == PARM_DECL)
536         {
537           dump_int (di, "used", TREE_USED (t));
538           if (DECL_REGISTER (t))
539             dump_string_field (di, "spec", "register");
540         }
541       break;
542
543     case FUNCTION_DECL:
544       dump_child ("args", DECL_ARGUMENTS (t));
545       if (DECL_EXTERNAL (t))
546         dump_string_field (di, "body", "undefined");
547       if (TREE_PUBLIC (t))
548         dump_string_field (di, "link", "extern");
549       else
550         dump_string_field (di, "link", "static");
551       if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t))
552         dump_child ("body", DECL_SAVED_TREE (t));
553       break;
554
555     case INTEGER_CST:
556       if (TREE_INT_CST_HIGH (t))
557         dump_int (di, "high", TREE_INT_CST_HIGH (t));
558       dump_int (di, "low", TREE_INT_CST_LOW (t));
559       break;
560
561     case STRING_CST:
562       fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
563       dump_int (di, "lngt", TREE_STRING_LENGTH (t));
564       break;
565
566     case REAL_CST:
567       dump_real (di, "valu", TREE_REAL_CST_PTR (t));
568       break;
569
570     case FIXED_CST:
571       dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t));
572       break;
573
574     case TRUTH_NOT_EXPR:
575     case ADDR_EXPR:
576     case INDIRECT_REF:
577     case ALIGN_INDIRECT_REF:
578     case MISALIGNED_INDIRECT_REF:
579     case CLEANUP_POINT_EXPR:
580     case SAVE_EXPR:
581     case REALPART_EXPR:
582     case IMAGPART_EXPR:
583       /* These nodes are unary, but do not have code class `1'.  */
584       dump_child ("op 0", TREE_OPERAND (t, 0));
585       break;
586
587     case TRUTH_ANDIF_EXPR:
588     case TRUTH_ORIF_EXPR:
589     case INIT_EXPR:
590     case MODIFY_EXPR:
591     case COMPOUND_EXPR:
592     case PREDECREMENT_EXPR:
593     case PREINCREMENT_EXPR:
594     case POSTDECREMENT_EXPR:
595     case POSTINCREMENT_EXPR:
596       /* These nodes are binary, but do not have code class `2'.  */
597       dump_child ("op 0", TREE_OPERAND (t, 0));
598       dump_child ("op 1", TREE_OPERAND (t, 1));
599       break;
600
601     case GIMPLE_MODIFY_STMT:
602       dump_child ("op 0", GIMPLE_STMT_OPERAND (t, 0));
603       dump_child ("op 1", GIMPLE_STMT_OPERAND (t, 1));
604       break;
605
606     case COMPONENT_REF:
607       dump_child ("op 0", TREE_OPERAND (t, 0));
608       dump_child ("op 1", TREE_OPERAND (t, 1));
609       dump_child ("op 2", TREE_OPERAND (t, 2));
610       break;
611
612     case ARRAY_REF:
613     case ARRAY_RANGE_REF:
614       dump_child ("op 0", TREE_OPERAND (t, 0));
615       dump_child ("op 1", TREE_OPERAND (t, 1));
616       dump_child ("op 2", TREE_OPERAND (t, 2));
617       dump_child ("op 3", TREE_OPERAND (t, 3));
618       break;
619
620     case COND_EXPR:
621       dump_child ("op 0", TREE_OPERAND (t, 0));
622       dump_child ("op 1", TREE_OPERAND (t, 1));
623       dump_child ("op 2", TREE_OPERAND (t, 2));
624       break;
625
626     case TRY_FINALLY_EXPR:
627       dump_child ("op 0", TREE_OPERAND (t, 0));
628       dump_child ("op 1", TREE_OPERAND (t, 1));
629       break;
630
631     case CALL_EXPR:
632       {
633         int i = 0;
634         tree arg;
635         call_expr_arg_iterator iter;
636         dump_child ("fn", CALL_EXPR_FN (t));
637         FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
638           {
639             char buffer[32];
640             sprintf (buffer, "%u", i);
641             dump_child (buffer, arg);
642             i++;
643           }
644       }
645       break;
646
647     case CONSTRUCTOR:
648       {
649         unsigned HOST_WIDE_INT cnt;
650         tree index, value;
651         dump_int (di, "lngt", VEC_length (constructor_elt,
652                                           CONSTRUCTOR_ELTS (t)));
653         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
654           {
655             dump_child ("idx", index);
656             dump_child ("val", value);
657           }
658       }
659       break;
660
661     case BIND_EXPR:
662       dump_child ("vars", TREE_OPERAND (t, 0));
663       dump_child ("body", TREE_OPERAND (t, 1));
664       break;
665
666     case LOOP_EXPR:
667       dump_child ("body", TREE_OPERAND (t, 0));
668       break;
669
670     case EXIT_EXPR:
671       dump_child ("cond", TREE_OPERAND (t, 0));
672       break;
673
674     case RETURN_EXPR:
675       dump_child ("expr", TREE_OPERAND (t, 0));
676       break;
677
678     case TARGET_EXPR:
679       dump_child ("decl", TREE_OPERAND (t, 0));
680       dump_child ("init", TREE_OPERAND (t, 1));
681       dump_child ("clnp", TREE_OPERAND (t, 2));
682       /* There really are two possible places the initializer can be.
683          After RTL expansion, the second operand is moved to the
684          position of the fourth operand, and the second operand
685          becomes NULL.  */
686       dump_child ("init", TREE_OPERAND (t, 3));
687       break;
688
689     case CASE_LABEL_EXPR:
690       dump_child ("name", CASE_LABEL (t));
691       if (CASE_LOW (t))
692         {
693           dump_child ("low ", CASE_LOW (t));
694           if (CASE_HIGH (t))
695             dump_child ("high", CASE_HIGH (t));
696         }
697       break;
698     case LABEL_EXPR:
699       dump_child ("name", TREE_OPERAND (t,0));
700       break;
701     case GOTO_EXPR:
702       dump_child ("labl", TREE_OPERAND (t, 0));
703       break;
704     case SWITCH_EXPR:
705       dump_child ("cond", TREE_OPERAND (t, 0));
706       dump_child ("body", TREE_OPERAND (t, 1));
707       if (TREE_OPERAND (t, 2))
708         {
709           dump_child ("labl", TREE_OPERAND (t,2));
710         }
711       break;
712     case OMP_CLAUSE:
713       {
714         int i;
715         fprintf (di->stream, "%s\n", omp_clause_code_name[OMP_CLAUSE_CODE (t)]);
716         for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++)
717           dump_child ("op: ", OMP_CLAUSE_OPERAND (t, i));
718       }
719       break;
720     default:
721       /* There are no additional fields to print.  */
722       break;
723     }
724
725  done:
726   if (dump_flag (di, TDF_ADDRESS, NULL))
727     dump_pointer (di, "addr", (void *)t);
728
729   /* Terminate the line.  */
730   fprintf (di->stream, "\n");
731 }
732
733 /* Return nonzero if FLAG has been specified for the dump, and NODE
734    is not the root node of the dump.  */
735
736 int dump_flag (dump_info_p di, int flag, const_tree node)
737 {
738   return (di->flags & flag) && (node != di->node);
739 }
740
741 /* Dump T, and all its children, on STREAM.  */
742
743 void
744 dump_node (const_tree t, int flags, FILE *stream)
745 {
746   struct dump_info di;
747   dump_queue_p dq;
748   dump_queue_p next_dq;
749
750   /* Initialize the dump-information structure.  */
751   di.stream = stream;
752   di.index = 0;
753   di.column = 0;
754   di.queue = 0;
755   di.queue_end = 0;
756   di.free_list = 0;
757   di.flags = flags;
758   di.node = t;
759   di.nodes = splay_tree_new (splay_tree_compare_pointers, 0,
760                              (splay_tree_delete_value_fn) &free);
761
762   /* Queue up the first node.  */
763   queue (&di, t, DUMP_NONE);
764
765   /* Until the queue is empty, keep dumping nodes.  */
766   while (di.queue)
767     dequeue_and_dump (&di);
768
769   /* Now, clean up.  */
770   for (dq = di.free_list; dq; dq = next_dq)
771     {
772       next_dq = dq->next;
773       free (dq);
774     }
775   splay_tree_delete (di.nodes);
776 }
777 \f
778
779 /* Table of tree dump switches. This must be consistent with the
780    tree_dump_index enumeration in tree-pass.h.  */
781 static struct dump_file_info dump_files[TDI_end] =
782 {
783   {NULL, NULL, NULL, 0, 0, 0},
784   {".cgraph", "ipa-cgraph", NULL, TDF_IPA, 0,  0},
785   {".tu", "translation-unit", NULL, TDF_TREE, 0, 1},
786   {".class", "class-hierarchy", NULL, TDF_TREE, 0, 2},
787   {".original", "tree-original", NULL, TDF_TREE, 0, 3},
788   {".gimple", "tree-gimple", NULL, TDF_TREE, 0, 4},
789   {".nested", "tree-nested", NULL, TDF_TREE, 0, 5},
790   {".vcg", "tree-vcg", NULL, TDF_TREE, 0, 6},
791 #define FIRST_AUTO_NUMBERED_DUMP 7
792
793   {NULL, "tree-all", NULL, TDF_TREE, 0, 0},
794   {NULL, "rtl-all", NULL, TDF_RTL, 0, 0},
795   {NULL, "ipa-all", NULL, TDF_IPA, 0, 0},
796 };
797
798 /* Dynamically registered tree dump files and switches.  */
799 static struct dump_file_info *extra_dump_files;
800 static size_t extra_dump_files_in_use;
801 static size_t extra_dump_files_alloced;
802
803 /* Define a name->number mapping for a dump flag value.  */
804 struct dump_option_value_info
805 {
806   const char *const name;       /* the name of the value */
807   const int value;              /* the value of the name */
808 };
809
810 /* Table of dump options. This must be consistent with the TDF_* flags
811    in tree.h */
812 static const struct dump_option_value_info dump_options[] =
813 {
814   {"address", TDF_ADDRESS},
815   {"slim", TDF_SLIM},
816   {"raw", TDF_RAW},
817   {"details", TDF_DETAILS},
818   {"stats", TDF_STATS},
819   {"blocks", TDF_BLOCKS},
820   {"vops", TDF_VOPS},
821   {"lineno", TDF_LINENO},
822   {"uid", TDF_UID},
823   {"stmtaddr", TDF_STMTADDR},
824   {"memsyms", TDF_MEMSYMS},
825   {"verbose", TDF_VERBOSE},
826   {"all", ~(TDF_RAW | TDF_SLIM | TDF_LINENO | TDF_TREE | TDF_RTL | TDF_IPA 
827             | TDF_STMTADDR | TDF_GRAPH | TDF_DIAGNOSTIC | TDF_VERBOSE)},
828   {NULL, 0}
829 };
830
831 unsigned int
832 dump_register (const char *suffix, const char *swtch, const char *glob,
833                int flags)
834 {
835   static int next_dump = FIRST_AUTO_NUMBERED_DUMP;
836   int num = next_dump++;
837
838   size_t this = extra_dump_files_in_use++;
839
840   if (this >= extra_dump_files_alloced)
841     {
842       if (extra_dump_files_alloced == 0)
843         extra_dump_files_alloced = 32;
844       else
845         extra_dump_files_alloced *= 2;
846       extra_dump_files = xrealloc (extra_dump_files,
847                                    sizeof (struct dump_file_info)
848                                    * extra_dump_files_alloced);
849     }
850
851   memset (&extra_dump_files[this], 0, sizeof (struct dump_file_info));
852   extra_dump_files[this].suffix = suffix;
853   extra_dump_files[this].swtch = swtch;
854   extra_dump_files[this].glob = glob;
855   extra_dump_files[this].flags = flags;
856   extra_dump_files[this].num = num;
857
858   return this + TDI_end;
859 }
860
861
862 /* Return the dump_file_info for the given phase.  */
863
864 struct dump_file_info *
865 get_dump_file_info (enum tree_dump_index phase)
866 {
867   if (phase < TDI_end)
868     return &dump_files[phase];
869   else if (phase - TDI_end >= extra_dump_files_in_use)
870     return NULL;
871   else
872     return extra_dump_files + (phase - TDI_end);
873 }
874
875
876 /* Return the name of the dump file for the given phase.
877    If the dump is not enabled, returns NULL.  */
878
879 char *
880 get_dump_file_name (enum tree_dump_index phase)
881 {
882   char dump_id[10];
883   struct dump_file_info *dfi;
884
885   if (phase == TDI_none)
886     return NULL;
887
888   dfi = get_dump_file_info (phase);
889   if (dfi->state == 0)
890     return NULL;
891
892   if (dfi->num < 0)
893     dump_id[0] = '\0';
894   else
895     {
896       char suffix;
897       if (dfi->flags & TDF_TREE)
898         suffix = 't';
899       else if (dfi->flags & TDF_IPA)
900         suffix = 'i';
901       else
902         suffix = 'r';
903
904       if (snprintf (dump_id, sizeof (dump_id), ".%03d%c", dfi->num, suffix) < 0)
905         dump_id[0] = '\0';
906     }
907
908   return concat (dump_base_name, dump_id, dfi->suffix, NULL);
909 }
910
911 /* Begin a tree dump for PHASE. Stores any user supplied flag in
912    *FLAG_PTR and returns a stream to write to. If the dump is not
913    enabled, returns NULL.
914    Multiple calls will reopen and append to the dump file.  */
915
916 FILE *
917 dump_begin (enum tree_dump_index phase, int *flag_ptr)
918 {
919   char *name;
920   struct dump_file_info *dfi;
921   FILE *stream;
922
923   if (phase == TDI_none || !dump_enabled_p (phase))
924     return NULL;
925
926   name = get_dump_file_name (phase);
927   dfi = get_dump_file_info (phase);
928   stream = fopen (name, dfi->state < 0 ? "w" : "a");
929   if (!stream)
930     error ("could not open dump file %qs: %s", name, strerror (errno));
931   else
932     dfi->state = 1;
933   free (name);
934
935   if (flag_ptr)
936     *flag_ptr = dfi->flags;
937
938   return stream;
939 }
940
941 /* Returns nonzero if tree dump PHASE is enabled.  If PHASE is
942    TDI_tree_all, return nonzero if any dump is enabled.  */
943
944 int
945 dump_enabled_p (enum tree_dump_index phase)
946 {
947   if (phase == TDI_tree_all)
948     {
949       size_t i;
950       for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
951         if (dump_files[i].state)
952           return 1;
953       for (i = 0; i < extra_dump_files_in_use; i++)
954         if (extra_dump_files[i].state)
955           return 1;
956       return 0;
957     }
958   else
959     {
960       struct dump_file_info *dfi = get_dump_file_info (phase);
961       return dfi->state;
962     }
963 }
964
965 /* Returns nonzero if tree dump PHASE has been initialized.  */
966
967 int
968 dump_initialized_p (enum tree_dump_index phase)
969 {
970   struct dump_file_info *dfi = get_dump_file_info (phase);
971   return dfi->state > 0;
972 }
973
974 /* Returns the switch name of PHASE.  */
975
976 const char *
977 dump_flag_name (enum tree_dump_index phase)
978 {
979   struct dump_file_info *dfi = get_dump_file_info (phase);
980   return dfi->swtch;
981 }
982
983 /* Finish a tree dump for PHASE. STREAM is the stream created by
984    dump_begin.  */
985
986 void
987 dump_end (enum tree_dump_index phase ATTRIBUTE_UNUSED, FILE *stream)
988 {
989   fclose (stream);
990 }
991
992 /* Enable all tree dumps.  Return number of enabled tree dumps.  */
993
994 static int
995 dump_enable_all (int flags)
996 {
997   int ir_dump_type = (flags & (TDF_TREE | TDF_RTL | TDF_IPA));
998   int n = 0;
999   size_t i;
1000
1001   for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
1002     if ((dump_files[i].flags & ir_dump_type))
1003       {
1004         dump_files[i].state = -1;
1005         dump_files[i].flags |= flags;
1006         n++;
1007       }
1008
1009   for (i = 0; i < extra_dump_files_in_use; i++)
1010     if ((extra_dump_files[i].flags & ir_dump_type))
1011       {
1012         extra_dump_files[i].state = -1;
1013         extra_dump_files[i].flags |= flags;
1014         n++;
1015       }
1016
1017   return n;
1018 }
1019
1020 /* Parse ARG as a dump switch. Return nonzero if it is, and store the
1021    relevant details in the dump_files array.  */
1022
1023 static int
1024 dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob)
1025 {
1026   const char *option_value;
1027   const char *ptr;
1028   int flags;
1029   
1030   if (doglob && !dfi->glob)
1031     return 0;
1032
1033   option_value = skip_leading_substring (arg, doglob ? dfi->glob : dfi->swtch);
1034   if (!option_value)
1035     return 0;
1036
1037   if (*option_value && *option_value != '-')
1038     return 0;
1039
1040   ptr = option_value;
1041   flags = 0;
1042
1043   while (*ptr)
1044     {
1045       const struct dump_option_value_info *option_ptr;
1046       const char *end_ptr;
1047       unsigned length;
1048
1049       while (*ptr == '-')
1050         ptr++;
1051       end_ptr = strchr (ptr, '-');
1052       if (!end_ptr)
1053         end_ptr = ptr + strlen (ptr);
1054       length = end_ptr - ptr;
1055
1056       for (option_ptr = dump_options; option_ptr->name; option_ptr++)
1057         if (strlen (option_ptr->name) == length
1058             && !memcmp (option_ptr->name, ptr, length))
1059           {
1060             flags |= option_ptr->value;
1061             goto found;
1062           }
1063       warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",
1064                length, ptr, dfi->swtch);
1065     found:;
1066       ptr = end_ptr;
1067     }
1068
1069   dfi->state = -1;
1070   dfi->flags |= flags;
1071
1072   /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the
1073      known dumps.  */
1074   if (dfi->suffix == NULL)
1075     dump_enable_all (dfi->flags);
1076
1077   return 1;
1078 }
1079
1080 int
1081 dump_switch_p (const char *arg)
1082 {
1083   size_t i;
1084   int any = 0;
1085
1086   for (i = TDI_none + 1; i != TDI_end; i++)
1087     any |= dump_switch_p_1 (arg, &dump_files[i], false);
1088
1089   /* Don't glob if we got a hit already */
1090   if (!any)
1091     for (i = TDI_none + 1; i != TDI_end; i++)
1092       any |= dump_switch_p_1 (arg, &dump_files[i], true);
1093
1094   for (i = 0; i < extra_dump_files_in_use; i++)
1095     any |= dump_switch_p_1 (arg, &extra_dump_files[i], false);
1096   
1097   if (!any)
1098     for (i = 0; i < extra_dump_files_in_use; i++)
1099       any |= dump_switch_p_1 (arg, &extra_dump_files[i], true);
1100
1101
1102   return any;
1103 }
1104
1105 /* Dump FUNCTION_DECL FN as tree dump PHASE.  */
1106
1107 void
1108 dump_function (enum tree_dump_index phase, tree fn)
1109 {
1110   FILE *stream;
1111   int flags;
1112
1113   stream = dump_begin (phase, &flags);
1114   if (stream)
1115     {
1116       dump_function_to_file (fn, stream, flags);
1117       dump_end (phase, stream);
1118     }
1119 }
1120
1121 bool
1122 enable_rtl_dump_file (void)
1123 {
1124   return dump_enable_all (TDF_RTL | TDF_DETAILS | TDF_BLOCKS) > 0;
1125 }
1126
1127