dump.c revision 132718 
1/* Tree-dumping functionality for intermediate representation.
2   Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3   Written by Mark Mitchell <mark@codesourcery.com>
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2, or (at your option)
10any later version.
11
12GCC is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING.  If not, write to
19the Free Software Foundation, 59 Temple Place - Suite 330,
20Boston, MA 02111-1307, USA.  */
21
22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "tm.h"
26#include "tree.h"
27#include "cp-tree.h"
28#include "tree-dump.h"
29
30static void dump_access (dump_info_p, tree);
31
32static void dump_op (dump_info_p, tree);
33
34/* Dump a representation of the accessibility information associated
35   with T.  */
36
37static void
38dump_access (dump_info_p di, tree t)
39{
40  if (TREE_PROTECTED(t))
41    dump_string (di, "protected");
42  else if (TREE_PRIVATE(t))
43    dump_string (di, "private");
44  else
45    dump_string (di, "public");
46}
47
48/* Dump a representation of the specific operator for an overloaded
49   operator associated with node t.  */
50
51static void
52dump_op (dump_info_p di, tree t)
53{
54  switch (DECL_OVERLOADED_OPERATOR_P (t)) {
55    case NEW_EXPR:
56      dump_string (di, "new");
57      break;
58    case VEC_NEW_EXPR:
59      dump_string (di, "vecnew");
60      break;
61    case DELETE_EXPR:
62      dump_string (di, "delete");
63      break;
64    case VEC_DELETE_EXPR:
65      dump_string (di, "vecdelete");
66      break;
67    case CONVERT_EXPR:
68      dump_string (di, "pos");
69      break;
70    case NEGATE_EXPR:
71      dump_string (di, "neg");
72      break;
73    case ADDR_EXPR:
74      dump_string (di, "addr");
75      break;
76    case INDIRECT_REF:
77      dump_string(di, "deref");
78      break;
79    case BIT_NOT_EXPR:
80      dump_string(di, "not");
81      break;
82    case TRUTH_NOT_EXPR:
83      dump_string(di, "lnot");
84      break;
85    case PREINCREMENT_EXPR:
86      dump_string(di, "preinc");
87      break;
88    case PREDECREMENT_EXPR:
89      dump_string(di, "predec");
90      break;
91    case PLUS_EXPR:
92      if (DECL_ASSIGNMENT_OPERATOR_P (t))
93        dump_string (di, "plusassign");
94      else
95        dump_string(di, "plus");
96      break;
97    case MINUS_EXPR:
98      if (DECL_ASSIGNMENT_OPERATOR_P (t))
99        dump_string (di, "minusassign");
100      else
101        dump_string(di, "minus");
102      break;
103    case MULT_EXPR:
104      if (DECL_ASSIGNMENT_OPERATOR_P (t))
105        dump_string (di, "multassign");
106      else
107        dump_string (di, "mult");
108      break;
109    case TRUNC_DIV_EXPR:
110      if (DECL_ASSIGNMENT_OPERATOR_P (t))
111        dump_string (di, "divassign");
112      else
113        dump_string (di, "div");
114      break;
115    case TRUNC_MOD_EXPR:
116      if (DECL_ASSIGNMENT_OPERATOR_P (t))
117         dump_string (di, "modassign");
118      else
119        dump_string (di, "mod");
120      break;
121    case BIT_AND_EXPR:
122      if (DECL_ASSIGNMENT_OPERATOR_P (t))
123        dump_string (di, "andassign");
124      else
125        dump_string (di, "and");
126      break;
127    case BIT_IOR_EXPR:
128      if (DECL_ASSIGNMENT_OPERATOR_P (t))
129        dump_string (di, "orassign");
130      else
131        dump_string (di, "or");
132      break;
133    case BIT_XOR_EXPR:
134      if (DECL_ASSIGNMENT_OPERATOR_P (t))
135        dump_string (di, "xorassign");
136      else
137        dump_string (di, "xor");
138      break;
139    case LSHIFT_EXPR:
140      if (DECL_ASSIGNMENT_OPERATOR_P (t))
141        dump_string (di, "lshiftassign");
142      else
143        dump_string (di, "lshift");
144      break;
145    case RSHIFT_EXPR:
146      if (DECL_ASSIGNMENT_OPERATOR_P (t))
147        dump_string (di, "rshiftassign");
148      else
149        dump_string (di, "rshift");
150      break;
151    case EQ_EXPR:
152      dump_string (di, "eq");
153      break;
154    case NE_EXPR:
155      dump_string (di, "ne");
156      break;
157    case LT_EXPR:
158      dump_string (di, "lt");
159      break;
160    case GT_EXPR:
161      dump_string (di, "gt");
162      break;
163    case LE_EXPR:
164      dump_string (di, "le");
165      break;
166    case GE_EXPR:
167      dump_string (di, "ge");
168      break;
169    case TRUTH_ANDIF_EXPR:
170      dump_string (di, "land");
171      break;
172    case TRUTH_ORIF_EXPR:
173      dump_string (di, "lor");
174      break;
175    case COMPOUND_EXPR:
176      dump_string (di, "compound");
177      break;
178    case MEMBER_REF:
179      dump_string (di, "memref");
180      break;
181    case COMPONENT_REF:
182      dump_string (di, "ref");
183      break;
184    case ARRAY_REF:
185      dump_string (di, "subs");
186      break;
187    case POSTINCREMENT_EXPR:
188      dump_string (di, "postinc");
189      break;
190    case POSTDECREMENT_EXPR:
191      dump_string (di, "postdec");
192      break;
193    case CALL_EXPR:
194      dump_string (di, "call");
195      break;
196    case NOP_EXPR:
197      if (DECL_ASSIGNMENT_OPERATOR_P (t))
198        dump_string (di, "assign");
199      break;
200    default:
201      break;
202  }
203}
204
205bool
206cp_dump_tree (void* dump_info, tree t)
207{
208  enum tree_code code;
209  dump_info_p di = (dump_info_p) dump_info;
210
211  /* Figure out what kind of node this is.  */
212  code = TREE_CODE (t);
213
214  if (DECL_P (t))
215    {
216      if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
217	dump_string (di, language_to_string (DECL_LANGUAGE (t)));
218    }
219
220  switch (code)
221    {
222    case IDENTIFIER_NODE:
223      if (IDENTIFIER_OPNAME_P (t))
224	{
225	  dump_string (di, "operator");
226	  return true;
227	}
228      else if (IDENTIFIER_TYPENAME_P (t))
229	{
230	  dump_child ("tynm", TREE_TYPE (t));
231	  return true;
232	}
233      break;
234
235    case OFFSET_TYPE:
236      dump_string (di, "ptrmem");
237      dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
238      dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
239      return true;
240
241    case RECORD_TYPE:
242      if (TYPE_PTRMEMFUNC_P (t))
243	{
244	  dump_string (di, "ptrmem");
245	  dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
246	  dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
247	  return true;
248	}
249      /* Fall through.  */
250
251    case UNION_TYPE:
252      /* Is it a type used as a base? */
253      if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t)
254	  && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t)
255	{
256	  dump_child ("bfld", TYPE_CONTEXT (t));
257	  return true;
258	}
259
260      if (! IS_AGGR_TYPE (t))
261	break;
262
263      dump_child ("vfld", TYPE_VFIELD (t));
264      if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t))
265        dump_string(di, "spec");
266
267      if (!dump_flag (di, TDF_SLIM, t))
268	{
269	  int i;
270
271	  for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); ++i)
272	    {
273	      tree base_binfo = BINFO_BASETYPE (TYPE_BINFO (t), i);
274	      dump_child ("base", BINFO_TYPE (base_binfo));
275	      if (TREE_VIA_VIRTUAL (base_binfo))
276		dump_string (di, "virtual");
277	      dump_access (di, base_binfo);
278	    }
279	}
280      break;
281
282    case FIELD_DECL:
283      dump_access (di, t);
284      if (DECL_MUTABLE_P (t))
285        dump_string(di, "mutable");
286      break;
287
288    case VAR_DECL:
289      if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE)
290        dump_access (di, t);
291      if (TREE_STATIC (t) && !TREE_PUBLIC (t))
292        dump_string (di, "static");
293      break;
294
295    case FUNCTION_DECL:
296      if (!DECL_THUNK_P (t))
297	{
298          if (DECL_OVERLOADED_OPERATOR_P (t)) {
299	    dump_string (di, "operator");
300            dump_op (di, t);
301          }
302	  if (DECL_FUNCTION_MEMBER_P (t))
303	    {
304	      dump_string (di, "member");
305	      dump_access (di, t);
306	    }
307          if (DECL_PURE_VIRTUAL_P (t))
308            dump_string (di, "pure");
309          if (DECL_VIRTUAL_P (t))
310            dump_string (di, "virtual");
311	  if (DECL_CONSTRUCTOR_P (t))
312	    dump_string (di, "constructor");
313	  if (DECL_DESTRUCTOR_P (t))
314	    dump_string (di, "destructor");
315	  if (DECL_CONV_FN_P (t))
316	    dump_string (di, "conversion");
317	  if (DECL_GLOBAL_CTOR_P (t))
318	    dump_string (di, "global init");
319	  if (DECL_GLOBAL_DTOR_P (t))
320	    dump_string (di, "global fini");
321	  if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t))
322	    dump_string (di, "pseudo tmpl");
323	}
324      else
325	{
326	  tree virt = THUNK_VIRTUAL_OFFSET (t);
327
328	  dump_string (di, "thunk");
329	  if (DECL_THIS_THUNK_P (t))
330	    dump_string (di, "this adjusting");
331	  else
332	    {
333	      dump_string (di, "result adjusting");
334	      if (virt)
335		virt = BINFO_VPTR_FIELD (virt);
336	    }
337	  dump_int (di, "fixd", THUNK_FIXED_OFFSET (t));
338	  if (virt)
339	    dump_int (di, "virt", tree_low_cst (virt, 0));
340	  dump_child ("fn", DECL_INITIAL (t));
341	}
342      break;
343
344    case NAMESPACE_DECL:
345      if (DECL_NAMESPACE_ALIAS (t))
346	dump_child ("alis", DECL_NAMESPACE_ALIAS (t));
347      else if (!dump_flag (di, TDF_SLIM, t))
348	dump_child ("dcls", cp_namespace_decls (t));
349      break;
350
351    case TEMPLATE_DECL:
352      dump_child ("rslt", DECL_TEMPLATE_RESULT (t));
353      dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t));
354      dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t));
355      dump_child ("prms", DECL_TEMPLATE_PARMS (t));
356      break;
357
358    case OVERLOAD:
359      dump_child ("crnt", OVL_CURRENT (t));
360      dump_child ("chan", OVL_CHAIN (t));
361      break;
362
363    case TRY_BLOCK:
364      dump_stmt (di, t);
365      if (CLEANUP_P (t))
366	dump_string (di, "cleanup");
367      dump_child ("body", TRY_STMTS (t));
368      dump_child ("hdlr", TRY_HANDLERS (t));
369      dump_next_stmt (di, t);
370      break;
371
372    case EH_SPEC_BLOCK:
373      dump_stmt (di, t);
374      dump_child ("body", EH_SPEC_STMTS (t));
375      dump_child ("raises", EH_SPEC_RAISES (t));
376      dump_next_stmt (di, t);
377      break;
378
379    case PTRMEM_CST:
380      dump_child ("clas", PTRMEM_CST_CLASS (t));
381      dump_child ("mbr", PTRMEM_CST_MEMBER (t));
382      break;
383
384    case THROW_EXPR:
385      /* These nodes are unary, but do not have code class `1'.  */
386      dump_child ("op 0", TREE_OPERAND (t, 0));
387      break;
388
389    case AGGR_INIT_EXPR:
390      dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
391      dump_child ("fn", TREE_OPERAND (t, 0));
392      dump_child ("args", TREE_OPERAND (t, 1));
393      dump_child ("decl", TREE_OPERAND (t, 2));
394      break;
395
396    case HANDLER:
397      dump_stmt (di, t);
398      dump_child ("parm", HANDLER_PARMS (t));
399      dump_child ("body", HANDLER_BODY (t));
400      dump_next_stmt (di, t);
401      break;
402
403    case MUST_NOT_THROW_EXPR:
404      dump_stmt (di, t);
405      dump_child ("body", TREE_OPERAND (t, 0));
406      dump_next_stmt (di, t);
407      break;
408
409    case USING_STMT:
410      dump_stmt (di, t);
411      dump_child ("nmsp", USING_STMT_NAMESPACE (t));
412      dump_next_stmt (di, t);
413      break;
414
415    default:
416      break;
417    }
418
419  return c_dump_tree (di, t);
420}
421