Branch data Line data Source code
1 : : /* Tree-dumping functionality for intermediate representation.
2 : : Copyright (C) 1999-2024 Free Software Foundation, Inc.
3 : : Written by Mark Mitchell <mark@codesourcery.com>
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify
8 : : it under the terms of the GNU General Public License as published by
9 : : the Free Software Foundation; either version 3, or (at your option)
10 : : any later version.
11 : :
12 : : GCC is distributed in the hope that it will be useful,
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
18 : : along with GCC; see the file COPYING3. If not see
19 : : <http://www.gnu.org/licenses/>. */
20 : :
21 : : #include "config.h"
22 : : #include "system.h"
23 : : #include "coretypes.h"
24 : : #include "cp-tree.h"
25 : : #include "tree-dump.h"
26 : :
27 : : /* Dump a representation of the accessibility information associated
28 : : with T. */
29 : :
30 : : static void
31 : 72 : dump_access (dump_info_p di, tree t)
32 : : {
33 : 72 : if (TREE_PROTECTED(t))
34 : 0 : dump_string_field (di, "accs", "prot");
35 : 72 : else if (TREE_PRIVATE(t))
36 : 0 : dump_string_field (di, "accs", "priv");
37 : : else
38 : 72 : dump_string_field (di, "accs", "pub");
39 : 72 : }
40 : :
41 : : /* Dump information common to statements from STMT. */
42 : :
43 : : static void
44 : 5 : dump_stmt (dump_info_p di, const_tree t)
45 : : {
46 : 5 : if (EXPR_HAS_LOCATION (t))
47 : 5 : dump_int (di, "line", EXPR_LINENO (t));
48 : 5 : }
49 : :
50 : : bool
51 : 20993 : cp_dump_tree (void* dump_info, tree t)
52 : : {
53 : 20993 : enum tree_code code;
54 : 20993 : dump_info_p di = (dump_info_p) dump_info;
55 : :
56 : : /* Figure out what kind of node this is. */
57 : 20993 : code = TREE_CODE (t);
58 : :
59 : 20993 : if (DECL_P (t))
60 : : {
61 : 7308 : if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
62 : 6984 : dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t)));
63 : : }
64 : :
65 : 20993 : switch (code)
66 : : {
67 : 8565 : case IDENTIFIER_NODE:
68 : 8565 : if (IDENTIFIER_ANY_OP_P (t))
69 : : {
70 : 12 : dump_string_field (di, "note", "operator");
71 : 12 : return true;
72 : : }
73 : : else if (IDENTIFIER_CONV_OP_P (t))
74 : : {
75 : : dump_child ("tynm", TREE_TYPE (t));
76 : : return true;
77 : : }
78 : : break;
79 : :
80 : 0 : case OFFSET_TYPE:
81 : 0 : dump_string_field (di, "note", "ptrmem");
82 : 0 : dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
83 : 0 : dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
84 : 0 : return true;
85 : :
86 : 39 : case RECORD_TYPE:
87 : 39 : if (TYPE_PTRMEMFUNC_P (t))
88 : : {
89 : 0 : dump_string_field (di, "note", "ptrmem");
90 : 0 : dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
91 : 0 : dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
92 : 0 : return true;
93 : : }
94 : : /* Fall through. */
95 : :
96 : 39 : case UNION_TYPE:
97 : : /* Is it a type used as a base? */
98 : 57 : if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t)
99 : 42 : && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t)
100 : : {
101 : 3 : dump_child ("bfld", TYPE_CONTEXT (t));
102 : 3 : return true;
103 : : }
104 : :
105 : 36 : if (! MAYBE_CLASS_TYPE_P (t))
106 : : break;
107 : :
108 : 33 : dump_child ("vfld", TYPE_VFIELD (t));
109 : 33 : if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t))
110 : 0 : dump_string(di, "spec");
111 : :
112 : 33 : if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t))
113 : : {
114 : 30 : int i;
115 : 30 : tree binfo;
116 : 30 : tree base_binfo;
117 : :
118 : 36 : for (binfo = TYPE_BINFO (t), i = 0;
119 : 36 : BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
120 : : {
121 : 6 : dump_child ("base", BINFO_TYPE (base_binfo));
122 : 6 : if (BINFO_VIRTUAL_P (base_binfo))
123 : 0 : dump_string_field (di, "spec", "virt");
124 : 6 : dump_access (di, base_binfo);
125 : : }
126 : : }
127 : : break;
128 : :
129 : 36 : case FIELD_DECL:
130 : 36 : dump_access (di, t);
131 : 36 : if (DECL_MUTABLE_P (t))
132 : 0 : dump_string_field (di, "spec", "mutable");
133 : : break;
134 : :
135 : 15 : case VAR_DECL:
136 : 15 : if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE)
137 : 6 : dump_access (di, t);
138 : 15 : if (TREE_STATIC (t) && !TREE_PUBLIC (t))
139 : 0 : dump_string_field (di, "link", "static");
140 : : break;
141 : :
142 : 7033 : case FUNCTION_DECL:
143 : 7033 : if (!DECL_THUNK_P (t))
144 : : {
145 : 7033 : if (DECL_OVERLOADED_OPERATOR_P (t))
146 : 28 : dump_string_field (di, "note", "operator");
147 : 7033 : if (DECL_FUNCTION_MEMBER_P (t))
148 : : {
149 : 24 : dump_string_field (di, "note", "member");
150 : 24 : dump_access (di, t);
151 : : }
152 : 7033 : if (DECL_PURE_VIRTUAL_P (t))
153 : 0 : dump_string_field (di, "spec", "pure");
154 : 7033 : if (DECL_VIRTUAL_P (t))
155 : 18 : dump_string_field (di, "spec", "virt");
156 : 14066 : if (DECL_CONSTRUCTOR_P (t))
157 : 0 : dump_string_field (di, "note", "constructor");
158 : 14066 : if (DECL_DESTRUCTOR_P (t))
159 : 24 : dump_string_field (di, "note", "destructor");
160 : 7033 : if (DECL_CONV_FN_P (t))
161 : 0 : dump_string_field (di, "note", "conversion");
162 : 7033 : if (DECL_GLOBAL_CTOR_P (t))
163 : 0 : dump_string_field (di, "note", "global init");
164 : 7033 : if (DECL_GLOBAL_DTOR_P (t))
165 : 0 : dump_string_field (di, "note", "global fini");
166 : 7033 : if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t))
167 : 0 : dump_string_field (di, "note", "pseudo tmpl");
168 : : }
169 : : else
170 : : {
171 : 0 : tree virt = THUNK_VIRTUAL_OFFSET (t);
172 : :
173 : 0 : dump_string_field (di, "note", "thunk");
174 : 0 : if (DECL_THIS_THUNK_P (t))
175 : 0 : dump_string_field (di, "note", "this adjusting");
176 : : else
177 : : {
178 : 0 : dump_string_field (di, "note", "result adjusting");
179 : 0 : if (virt)
180 : 0 : virt = BINFO_VPTR_FIELD (virt);
181 : : }
182 : 0 : dump_int (di, "fixd", THUNK_FIXED_OFFSET (t));
183 : 0 : if (virt)
184 : 0 : dump_int (di, "virt", tree_to_shwi (virt));
185 : 0 : dump_child ("fn", DECL_INITIAL (t));
186 : : }
187 : : break;
188 : :
189 : 9 : case NAMESPACE_DECL:
190 : 9 : if (DECL_NAMESPACE_ALIAS (t))
191 : 0 : dump_child ("alis", DECL_NAMESPACE_ALIAS (t));
192 : 9 : else if (!dump_flag (di, TDF_SLIM, t))
193 : 9 : dump_child ("dcls", cp_namespace_decls (t));
194 : : break;
195 : :
196 : 0 : case TEMPLATE_DECL:
197 : 0 : dump_child ("rslt", DECL_TEMPLATE_RESULT (t));
198 : 0 : dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t));
199 : 0 : dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t));
200 : 0 : dump_child ("prms", DECL_TEMPLATE_PARMS (t));
201 : 0 : break;
202 : :
203 : : case OVERLOAD:
204 : 0 : dump_child ("name", OVL_NAME (t));
205 : 0 : if (!dump_flag (di, TDF_SLIM, t))
206 : 0 : for (lkp_iterator iter (t); iter; ++iter)
207 : 0 : dump_child ("chld", *iter);
208 : : break;
209 : :
210 : 0 : case TRY_BLOCK:
211 : 0 : dump_stmt (di, t);
212 : 0 : if (CLEANUP_P (t))
213 : 0 : dump_string_field (di, "note", "cleanup");
214 : 0 : dump_child ("body", TRY_STMTS (t));
215 : 0 : dump_child ("hdlr", TRY_HANDLERS (t));
216 : 0 : break;
217 : :
218 : 0 : case EH_SPEC_BLOCK:
219 : 0 : dump_stmt (di, t);
220 : 0 : dump_child ("body", EH_SPEC_STMTS (t));
221 : 0 : dump_child ("raises", EH_SPEC_RAISES (t));
222 : 0 : break;
223 : :
224 : 0 : case PTRMEM_CST:
225 : 0 : dump_child ("clas", PTRMEM_CST_CLASS (t));
226 : 0 : dump_child ("mbr", PTRMEM_CST_MEMBER (t));
227 : 0 : break;
228 : :
229 : 0 : case THROW_EXPR:
230 : : /* These nodes are unary, but do not have code class `1'. */
231 : 0 : dump_child ("op 0", TREE_OPERAND (t, 0));
232 : 0 : break;
233 : :
234 : 0 : case AGGR_INIT_EXPR:
235 : 0 : {
236 : 0 : int i = 0;
237 : 0 : tree arg;
238 : 0 : aggr_init_expr_arg_iterator iter;
239 : 0 : dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
240 : 0 : dump_child ("fn", AGGR_INIT_EXPR_FN (t));
241 : 0 : FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
242 : : {
243 : 0 : char buffer[32];
244 : 0 : sprintf (buffer, "%u", i);
245 : 0 : dump_child (buffer, arg);
246 : 0 : i++;
247 : : }
248 : 0 : dump_child ("decl", AGGR_INIT_EXPR_SLOT (t));
249 : : }
250 : 0 : break;
251 : :
252 : 0 : case HANDLER:
253 : 0 : dump_stmt (di, t);
254 : 0 : dump_child ("parm", HANDLER_PARMS (t));
255 : 0 : dump_child ("body", HANDLER_BODY (t));
256 : 0 : break;
257 : :
258 : 2 : case MUST_NOT_THROW_EXPR:
259 : 2 : dump_stmt (di, t);
260 : 2 : dump_child ("body", TREE_OPERAND (t, 0));
261 : 2 : dump_child ("cond", MUST_NOT_THROW_COND (t));
262 : 2 : break;
263 : :
264 : 0 : case USING_STMT:
265 : 0 : dump_stmt (di, t);
266 : 0 : dump_child ("nmsp", USING_STMT_NAMESPACE (t));
267 : 0 : break;
268 : :
269 : 0 : case CLEANUP_STMT:
270 : 0 : dump_stmt (di, t);
271 : 0 : dump_child ("decl", CLEANUP_DECL (t));
272 : 0 : dump_child ("expr", CLEANUP_EXPR (t));
273 : 0 : dump_child ("body", CLEANUP_BODY (t));
274 : 0 : break;
275 : :
276 : 0 : case IF_STMT:
277 : 0 : dump_stmt (di, t);
278 : 0 : dump_child ("cond", IF_COND (t));
279 : 0 : dump_child ("then", THEN_CLAUSE (t));
280 : 0 : dump_child ("else", ELSE_CLAUSE (t));
281 : 0 : break;
282 : :
283 : 0 : case RANGE_FOR_STMT:
284 : 0 : dump_stmt (di, t);
285 : 0 : dump_child ("init", RANGE_FOR_INIT_STMT (t));
286 : 0 : dump_child ("decl", RANGE_FOR_DECL (t));
287 : 0 : dump_child ("expr", RANGE_FOR_EXPR (t));
288 : 0 : dump_child ("body", RANGE_FOR_BODY (t));
289 : 0 : break;
290 : :
291 : 0 : case STMT_EXPR:
292 : 0 : dump_child ("stmt", STMT_EXPR_STMT (t));
293 : 0 : break;
294 : :
295 : 3 : case EXPR_STMT:
296 : 3 : dump_stmt (di, t);
297 : 3 : dump_child ("expr", EXPR_STMT_EXPR (t));
298 : 3 : break;
299 : :
300 : 0 : case OMP_DEPOBJ:
301 : 0 : dump_stmt (di, t);
302 : 0 : dump_child ("depobj", OMP_DEPOBJ_DEPOBJ (t));
303 : 0 : dump_child ("clauses", OMP_DEPOBJ_CLAUSES (t));
304 : 0 : break;
305 : :
306 : : default:
307 : : break;
308 : : }
309 : :
310 : 20978 : return c_dump_tree (di, t);
311 : : }
|
