]>
Commit | Line | Data |
---|---|---|
f71f87f9 | 1 | /* Tree-dumping functionality for intermediate representation. |
6e4ae815 | 2 | Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc. |
f71f87f9 MM |
3 | Written by Mark Mitchell <mark@codesourcery.com> |
4 | ||
f5adbb8d | 5 | This file is part of GCC. |
f71f87f9 | 6 | |
f5adbb8d | 7 | GCC is free software; you can redistribute it and/or modify |
f71f87f9 MM |
8 | it under the terms of the GNU General Public License as published by |
9 | the Free Software Foundation; either version 2, or (at your option) | |
10 | any later version. | |
11 | ||
f5adbb8d | 12 | GCC is distributed in the hope that it will be useful, |
f71f87f9 MM |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
f5adbb8d | 18 | along with GCC; see the file COPYING. If not, write to |
f71f87f9 MM |
19 | the Free Software Foundation, 59 Temple Place - Suite 330, |
20 | Boston, MA 02111-1307, USA. */ | |
21 | ||
f71f87f9 MM |
22 | #include "config.h" |
23 | #include "system.h" | |
4977bab6 ZW |
24 | #include "coretypes.h" |
25 | #include "tm.h" | |
f71f87f9 MM |
26 | #include "tree.h" |
27 | #include "cp-tree.h" | |
89d684bb | 28 | #include "tree-dump.h" |
f71f87f9 | 29 | |
ee42dd9d | 30 | static void dump_access (dump_info_p, tree); |
005a5cb0 | 31 | |
ee42dd9d | 32 | static void dump_op (dump_info_p, tree); |
78a40378 | 33 | |
005a5cb0 MY |
34 | /* Dump a representation of the accessibility information associated |
35 | with T. */ | |
36 | ||
37 | static void | |
ee42dd9d | 38 | dump_access (dump_info_p di, tree t) |
005a5cb0 MY |
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 | ||
78a40378 | 48 | /* Dump a representation of the specific operator for an overloaded |
558ee214 | 49 | operator associated with node t. */ |
78a40378 MM |
50 | |
51 | static void | |
ee42dd9d | 52 | dump_op (dump_info_p di, tree t) |
78a40378 MM |
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 | ||
2bd3ecad | 205 | bool |
ee42dd9d | 206 | cp_dump_tree (void* dump_info, tree t) |
f71f87f9 | 207 | { |
f71f87f9 | 208 | enum tree_code code; |
89d684bb | 209 | dump_info_p di = (dump_info_p) dump_info; |
f71f87f9 MM |
210 | |
211 | /* Figure out what kind of node this is. */ | |
212 | code = TREE_CODE (t); | |
f71f87f9 | 213 | |
0a7394bc | 214 | if (DECL_P (t)) |
f71f87f9 | 215 | { |
421844e7 | 216 | if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus) |
4e3f84b7 | 217 | dump_string (di, language_to_string (DECL_LANGUAGE (t))); |
f71f87f9 | 218 | } |
f71f87f9 | 219 | |
f71f87f9 MM |
220 | switch (code) |
221 | { | |
f71f87f9 MM |
222 | case IDENTIFIER_NODE: |
223 | if (IDENTIFIER_OPNAME_P (t)) | |
0a7394bc MM |
224 | { |
225 | dump_string (di, "operator"); | |
2bd3ecad | 226 | return true; |
0a7394bc | 227 | } |
f71f87f9 | 228 | else if (IDENTIFIER_TYPENAME_P (t)) |
f71f87f9 | 229 | { |
0a7394bc | 230 | dump_child ("tynm", TREE_TYPE (t)); |
2bd3ecad | 231 | return true; |
f71f87f9 | 232 | } |
f71f87f9 MM |
233 | break; |
234 | ||
a5ac359a MM |
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; | |
f71f87f9 MM |
240 | |
241 | case RECORD_TYPE: | |
f71f87f9 MM |
242 | if (TYPE_PTRMEMFUNC_P (t)) |
243 | { | |
244 | dump_string (di, "ptrmem"); | |
8badec73 MM |
245 | dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t)); |
246 | dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t)); | |
2bd3ecad | 247 | return true; |
f71f87f9 | 248 | } |
a5ac359a | 249 | /* Fall through. */ |
f71f87f9 | 250 | |
a5ac359a | 251 | case UNION_TYPE: |
5a5cccaa NS |
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)); | |
2bd3ecad | 257 | return true; |
5a5cccaa NS |
258 | } |
259 | ||
4e8dca1c JM |
260 | if (! IS_AGGR_TYPE (t)) |
261 | break; | |
262 | ||
0a7394bc | 263 | dump_child ("vfld", TYPE_VFIELD (t)); |
78a40378 MM |
264 | if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t)) |
265 | dump_string(di, "spec"); | |
b7442fb5 | 266 | |
3758425f | 267 | if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t)) |
b7442fb5 NS |
268 | { |
269 | int i; | |
fa743e8c NS |
270 | tree binfo; |
271 | tree base_binfo; | |
b7442fb5 | 272 | |
fa743e8c NS |
273 | for (binfo = TYPE_BINFO (t), i = 0; |
274 | BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) | |
b7442fb5 | 275 | { |
b7442fb5 | 276 | dump_child ("base", BINFO_TYPE (base_binfo)); |
809e3e7f | 277 | if (BINFO_VIRTUAL_P (base_binfo)) |
b7442fb5 NS |
278 | dump_string (di, "virtual"); |
279 | dump_access (di, base_binfo); | |
280 | } | |
281 | } | |
005a5cb0 MY |
282 | break; |
283 | ||
284 | case FIELD_DECL: | |
285 | dump_access (di, t); | |
78a40378 MM |
286 | if (DECL_MUTABLE_P (t)) |
287 | dump_string(di, "mutable"); | |
f71f87f9 MM |
288 | break; |
289 | ||
78a40378 MM |
290 | case VAR_DECL: |
291 | if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE) | |
292 | dump_access (di, t); | |
293 | if (TREE_STATIC (t) && !TREE_PUBLIC (t)) | |
294 | dump_string (di, "static"); | |
295 | break; | |
296 | ||
f71f87f9 | 297 | case FUNCTION_DECL: |
31f8e4f3 | 298 | if (!DECL_THUNK_P (t)) |
e9e7f181 | 299 | { |
78a40378 MM |
300 | if (DECL_OVERLOADED_OPERATOR_P (t)) { |
301 | dump_string (di, "operator"); | |
302 | dump_op (di, t); | |
303 | } | |
005a5cb0 MY |
304 | if (DECL_FUNCTION_MEMBER_P (t)) |
305 | { | |
306 | dump_string (di, "member"); | |
307 | dump_access (di, t); | |
308 | } | |
78a40378 MM |
309 | if (DECL_PURE_VIRTUAL_P (t)) |
310 | dump_string (di, "pure"); | |
311 | if (DECL_VIRTUAL_P (t)) | |
312 | dump_string (di, "virtual"); | |
e9e7f181 MM |
313 | if (DECL_CONSTRUCTOR_P (t)) |
314 | dump_string (di, "constructor"); | |
315 | if (DECL_DESTRUCTOR_P (t)) | |
316 | dump_string (di, "destructor"); | |
e9e7f181 MM |
317 | if (DECL_CONV_FN_P (t)) |
318 | dump_string (di, "conversion"); | |
4977bab6 ZW |
319 | if (DECL_GLOBAL_CTOR_P (t)) |
320 | dump_string (di, "global init"); | |
321 | if (DECL_GLOBAL_DTOR_P (t)) | |
322 | dump_string (di, "global fini"); | |
1c227897 MM |
323 | if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)) |
324 | dump_string (di, "pseudo tmpl"); | |
e9e7f181 MM |
325 | } |
326 | else | |
327 | { | |
07fa4878 NS |
328 | tree virt = THUNK_VIRTUAL_OFFSET (t); |
329 | ||
31f8e4f3 | 330 | dump_string (di, "thunk"); |
4977bab6 ZW |
331 | if (DECL_THIS_THUNK_P (t)) |
332 | dump_string (di, "this adjusting"); | |
333 | else | |
07fa4878 NS |
334 | { |
335 | dump_string (di, "result adjusting"); | |
336 | if (virt) | |
337 | virt = BINFO_VPTR_FIELD (virt); | |
338 | } | |
4977bab6 | 339 | dump_int (di, "fixd", THUNK_FIXED_OFFSET (t)); |
07fa4878 NS |
340 | if (virt) |
341 | dump_int (di, "virt", tree_low_cst (virt, 0)); | |
31f8e4f3 | 342 | dump_child ("fn", DECL_INITIAL (t)); |
e9e7f181 | 343 | } |
f71f87f9 MM |
344 | break; |
345 | ||
346 | case NAMESPACE_DECL: | |
89c6e7ac MM |
347 | if (DECL_NAMESPACE_ALIAS (t)) |
348 | dump_child ("alis", DECL_NAMESPACE_ALIAS (t)); | |
b7442fb5 | 349 | else if (!dump_flag (di, TDF_SLIM, t)) |
89c6e7ac | 350 | dump_child ("dcls", cp_namespace_decls (t)); |
f71f87f9 MM |
351 | break; |
352 | ||
cfe507be | 353 | case TEMPLATE_DECL: |
da8a7456 | 354 | dump_child ("rslt", DECL_TEMPLATE_RESULT (t)); |
2269eec3 | 355 | dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t)); |
3454335f | 356 | dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t)); |
005a5cb0 | 357 | dump_child ("prms", DECL_TEMPLATE_PARMS (t)); |
cfe507be MM |
358 | break; |
359 | ||
f71f87f9 | 360 | case OVERLOAD: |
3454335f MM |
361 | dump_child ("crnt", OVL_CURRENT (t)); |
362 | dump_child ("chan", OVL_CHAIN (t)); | |
f71f87f9 MM |
363 | break; |
364 | ||
0a7394bc | 365 | case TRY_BLOCK: |
f71f87f9 | 366 | dump_stmt (di, t); |
0a7394bc MM |
367 | if (CLEANUP_P (t)) |
368 | dump_string (di, "cleanup"); | |
369 | dump_child ("body", TRY_STMTS (t)); | |
370 | dump_child ("hdlr", TRY_HANDLERS (t)); | |
f71f87f9 MM |
371 | break; |
372 | ||
52a11cbf RH |
373 | case EH_SPEC_BLOCK: |
374 | dump_stmt (di, t); | |
375 | dump_child ("body", EH_SPEC_STMTS (t)); | |
376 | dump_child ("raises", EH_SPEC_RAISES (t)); | |
52a11cbf RH |
377 | break; |
378 | ||
0a7394bc MM |
379 | case PTRMEM_CST: |
380 | dump_child ("clas", PTRMEM_CST_CLASS (t)); | |
381 | dump_child ("mbr", PTRMEM_CST_MEMBER (t)); | |
f71f87f9 MM |
382 | break; |
383 | ||
0a7394bc MM |
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)); | |
f71f87f9 MM |
387 | break; |
388 | ||
0a7394bc MM |
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 | ||
a2edce31 MM |
396 | case HANDLER: |
397 | dump_stmt (di, t); | |
1a6025b4 | 398 | dump_child ("parm", HANDLER_PARMS (t)); |
a2edce31 | 399 | dump_child ("body", HANDLER_BODY (t)); |
a2edce31 MM |
400 | break; |
401 | ||
52a11cbf RH |
402 | case MUST_NOT_THROW_EXPR: |
403 | dump_stmt (di, t); | |
404 | dump_child ("body", TREE_OPERAND (t, 0)); | |
52a11cbf RH |
405 | break; |
406 | ||
5158d7ee NS |
407 | case USING_STMT: |
408 | dump_stmt (di, t); | |
409 | dump_child ("nmsp", USING_STMT_NAMESPACE (t)); | |
5158d7ee | 410 | break; |
5a508662 RH |
411 | |
412 | case CLEANUP_STMT: | |
413 | dump_stmt (di, t); | |
414 | dump_child ("decl", CLEANUP_DECL (t)); | |
415 | dump_child ("expr", CLEANUP_EXPR (t)); | |
416 | dump_child ("body", CLEANUP_BODY (t)); | |
5a508662 RH |
417 | break; |
418 | ||
419 | case IF_STMT: | |
420 | dump_stmt (di, t); | |
421 | dump_child ("cond", IF_COND (t)); | |
422 | dump_child ("then", THEN_CLAUSE (t)); | |
423 | dump_child ("else", ELSE_CLAUSE (t)); | |
5a508662 RH |
424 | break; |
425 | ||
f71f87f9 | 426 | default: |
f71f87f9 MM |
427 | break; |
428 | } | |
429 | ||
558ee214 | 430 | return c_dump_tree (di, t); |
f71f87f9 | 431 | } |