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