Merge branch 'vendor/GCC50' - gcc 5.0 snapshot 1 FEB 2015
[dragonfly.git] / contrib / gcc-5.0 / gcc / cp / dump.c
1 /* Tree-dumping functionality for intermediate representation.
2    Copyright (C) 1999-2015 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 "tm.h"
25 #include "hash-set.h"
26 #include "machmode.h"
27 #include "vec.h"
28 #include "double-int.h"
29 #include "input.h"
30 #include "alias.h"
31 #include "symtab.h"
32 #include "wide-int.h"
33 #include "inchash.h"
34 #include "tree.h"
35 #include "cp-tree.h"
36 #include "tree-dump.h"
37
38 static void dump_access (dump_info_p, tree);
39
40 static void dump_op (dump_info_p, tree);
41
42 /* Dump a representation of the accessibility information associated
43    with T.  */
44
45 static void
46 dump_access (dump_info_p di, tree t)
47 {
48   if (TREE_PROTECTED(t))
49     dump_string_field (di, "accs", "prot");
50   else if (TREE_PRIVATE(t))
51     dump_string_field (di, "accs", "priv");
52   else
53     dump_string_field (di, "accs", "pub");
54 }
55
56 /* Dump a representation of the specific operator for an overloaded
57    operator associated with node t.  */
58
59 static void
60 dump_op (dump_info_p di, tree t)
61 {
62   switch (DECL_OVERLOADED_OPERATOR_P (t)) {
63     case NEW_EXPR:
64       dump_string (di, "new");
65       break;
66     case VEC_NEW_EXPR:
67       dump_string (di, "vecnew");
68       break;
69     case DELETE_EXPR:
70       dump_string (di, "delete");
71       break;
72     case VEC_DELETE_EXPR:
73       dump_string (di, "vecdelete");
74       break;
75     case UNARY_PLUS_EXPR:
76       dump_string (di, "pos");
77       break;
78     case NEGATE_EXPR:
79       dump_string (di, "neg");
80       break;
81     case ADDR_EXPR:
82       dump_string (di, "addr");
83       break;
84     case INDIRECT_REF:
85       dump_string(di, "deref");
86       break;
87     case BIT_NOT_EXPR:
88       dump_string(di, "not");
89       break;
90     case TRUTH_NOT_EXPR:
91       dump_string(di, "lnot");
92       break;
93     case PREINCREMENT_EXPR:
94       dump_string(di, "preinc");
95       break;
96     case PREDECREMENT_EXPR:
97       dump_string(di, "predec");
98       break;
99     case PLUS_EXPR:
100       if (DECL_ASSIGNMENT_OPERATOR_P (t))
101         dump_string (di, "plusassign");
102       else
103         dump_string(di, "plus");
104       break;
105     case MINUS_EXPR:
106       if (DECL_ASSIGNMENT_OPERATOR_P (t))
107         dump_string (di, "minusassign");
108       else
109         dump_string(di, "minus");
110       break;
111     case MULT_EXPR:
112       if (DECL_ASSIGNMENT_OPERATOR_P (t))
113         dump_string (di, "multassign");
114       else
115         dump_string (di, "mult");
116       break;
117     case TRUNC_DIV_EXPR:
118       if (DECL_ASSIGNMENT_OPERATOR_P (t))
119         dump_string (di, "divassign");
120       else
121         dump_string (di, "div");
122       break;
123     case TRUNC_MOD_EXPR:
124       if (DECL_ASSIGNMENT_OPERATOR_P (t))
125          dump_string (di, "modassign");
126       else
127         dump_string (di, "mod");
128       break;
129     case BIT_AND_EXPR:
130       if (DECL_ASSIGNMENT_OPERATOR_P (t))
131         dump_string (di, "andassign");
132       else
133         dump_string (di, "and");
134       break;
135     case BIT_IOR_EXPR:
136       if (DECL_ASSIGNMENT_OPERATOR_P (t))
137         dump_string (di, "orassign");
138       else
139         dump_string (di, "or");
140       break;
141     case BIT_XOR_EXPR:
142       if (DECL_ASSIGNMENT_OPERATOR_P (t))
143         dump_string (di, "xorassign");
144       else
145         dump_string (di, "xor");
146       break;
147     case LSHIFT_EXPR:
148       if (DECL_ASSIGNMENT_OPERATOR_P (t))
149         dump_string (di, "lshiftassign");
150       else
151         dump_string (di, "lshift");
152       break;
153     case RSHIFT_EXPR:
154       if (DECL_ASSIGNMENT_OPERATOR_P (t))
155         dump_string (di, "rshiftassign");
156       else
157         dump_string (di, "rshift");
158       break;
159     case EQ_EXPR:
160       dump_string (di, "eq");
161       break;
162     case NE_EXPR:
163       dump_string (di, "ne");
164       break;
165     case LT_EXPR:
166       dump_string (di, "lt");
167       break;
168     case GT_EXPR:
169       dump_string (di, "gt");
170       break;
171     case LE_EXPR:
172       dump_string (di, "le");
173       break;
174     case GE_EXPR:
175       dump_string (di, "ge");
176       break;
177     case TRUTH_ANDIF_EXPR:
178       dump_string (di, "land");
179       break;
180     case TRUTH_ORIF_EXPR:
181       dump_string (di, "lor");
182       break;
183     case COMPOUND_EXPR:
184       dump_string (di, "compound");
185       break;
186     case MEMBER_REF:
187       dump_string (di, "memref");
188       break;
189     case COMPONENT_REF:
190       dump_string (di, "ref");
191       break;
192     case ARRAY_REF:
193       dump_string (di, "subs");
194       break;
195     case POSTINCREMENT_EXPR:
196       dump_string (di, "postinc");
197       break;
198     case POSTDECREMENT_EXPR:
199       dump_string (di, "postdec");
200       break;
201     case CALL_EXPR:
202       dump_string (di, "call");
203       break;
204     case NOP_EXPR:
205       if (DECL_ASSIGNMENT_OPERATOR_P (t))
206         dump_string (di, "assign");
207       break;
208     default:
209       break;
210   }
211 }
212
213 /* Dump information common to statements from STMT.  */
214
215 static void
216 dump_stmt (dump_info_p di, const_tree t)
217 {
218   if (EXPR_HAS_LOCATION (t))
219     dump_int (di, "line", EXPR_LINENO (t));
220 }
221
222 bool
223 cp_dump_tree (void* dump_info, tree t)
224 {
225   enum tree_code code;
226   dump_info_p di = (dump_info_p) dump_info;
227
228   /* Figure out what kind of node this is.  */
229   code = TREE_CODE (t);
230
231   if (DECL_P (t))
232     {
233       if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
234         dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t)));
235     }
236
237   switch (code)
238     {
239     case IDENTIFIER_NODE:
240       if (IDENTIFIER_OPNAME_P (t))
241         {
242           dump_string_field (di, "note", "operator");
243           return true;
244         }
245       else if (IDENTIFIER_TYPENAME_P (t))
246         {
247           dump_child ("tynm", TREE_TYPE (t));
248           return true;
249         }
250       break;
251
252     case OFFSET_TYPE:
253       dump_string_field (di, "note", "ptrmem");
254       dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
255       dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
256       return true;
257
258     case RECORD_TYPE:
259       if (TYPE_PTRMEMFUNC_P (t))
260         {
261           dump_string_field (di, "note", "ptrmem");
262           dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
263           dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
264           return true;
265         }
266       /* Fall through.  */
267
268     case UNION_TYPE:
269       /* Is it a type used as a base? */
270       if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t)
271           && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t)
272         {
273           dump_child ("bfld", TYPE_CONTEXT (t));
274           return true;
275         }
276
277       if (! MAYBE_CLASS_TYPE_P (t))
278         break;
279
280       dump_child ("vfld", TYPE_VFIELD (t));
281       if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t))
282         dump_string(di, "spec");
283
284       if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t))
285         {
286           int i;
287           tree binfo;
288           tree base_binfo;
289
290           for (binfo = TYPE_BINFO (t), i = 0;
291                BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
292             {
293               dump_child ("base", BINFO_TYPE (base_binfo));
294               if (BINFO_VIRTUAL_P (base_binfo))
295                 dump_string_field (di, "spec", "virt");
296               dump_access (di, base_binfo);
297             }
298         }
299       break;
300
301     case FIELD_DECL:
302       dump_access (di, t);
303       if (DECL_MUTABLE_P (t))
304         dump_string_field (di, "spec", "mutable");
305       break;
306
307     case VAR_DECL:
308       if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE)
309         dump_access (di, t);
310       if (TREE_STATIC (t) && !TREE_PUBLIC (t))
311         dump_string_field (di, "link", "static");
312       break;
313
314     case FUNCTION_DECL:
315       if (!DECL_THUNK_P (t))
316         {
317           if (DECL_OVERLOADED_OPERATOR_P (t)) {
318             dump_string_field (di, "note", "operator");
319             dump_op (di, t);
320           }
321           if (DECL_FUNCTION_MEMBER_P (t))
322             {
323               dump_string_field (di, "note", "member");
324               dump_access (di, t);
325             }
326           if (DECL_PURE_VIRTUAL_P (t))
327             dump_string_field (di, "spec", "pure");
328           if (DECL_VIRTUAL_P (t))
329             dump_string_field (di, "spec", "virt");
330           if (DECL_CONSTRUCTOR_P (t))
331             dump_string_field (di, "note", "constructor");
332           if (DECL_DESTRUCTOR_P (t))
333             dump_string_field (di, "note", "destructor");
334           if (DECL_CONV_FN_P (t))
335             dump_string_field (di, "note", "conversion");
336           if (DECL_GLOBAL_CTOR_P (t))
337             dump_string_field (di, "note", "global init");
338           if (DECL_GLOBAL_DTOR_P (t))
339             dump_string_field (di, "note", "global fini");
340           if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t))
341             dump_string_field (di, "note", "pseudo tmpl");
342         }
343       else
344         {
345           tree virt = THUNK_VIRTUAL_OFFSET (t);
346
347           dump_string_field (di, "note", "thunk");
348           if (DECL_THIS_THUNK_P (t))
349             dump_string_field (di, "note", "this adjusting");
350           else
351             {
352               dump_string_field (di, "note", "result adjusting");
353               if (virt)
354                 virt = BINFO_VPTR_FIELD (virt);
355             }
356           dump_int (di, "fixd", THUNK_FIXED_OFFSET (t));
357           if (virt)
358             dump_int (di, "virt", tree_to_shwi (virt));
359           dump_child ("fn", DECL_INITIAL (t));
360         }
361       break;
362
363     case NAMESPACE_DECL:
364       if (DECL_NAMESPACE_ALIAS (t))
365         dump_child ("alis", DECL_NAMESPACE_ALIAS (t));
366       else if (!dump_flag (di, TDF_SLIM, t))
367         dump_child ("dcls", cp_namespace_decls (t));
368       break;
369
370     case TEMPLATE_DECL:
371       dump_child ("rslt", DECL_TEMPLATE_RESULT (t));
372       dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t));
373       dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t));
374       dump_child ("prms", DECL_TEMPLATE_PARMS (t));
375       break;
376
377     case OVERLOAD:
378       dump_child ("crnt", OVL_CURRENT (t));
379       dump_child ("chan", OVL_CHAIN (t));
380       break;
381
382     case TRY_BLOCK:
383       dump_stmt (di, t);
384       if (CLEANUP_P (t))
385         dump_string_field (di, "note", "cleanup");
386       dump_child ("body", TRY_STMTS (t));
387       dump_child ("hdlr", TRY_HANDLERS (t));
388       break;
389
390     case EH_SPEC_BLOCK:
391       dump_stmt (di, t);
392       dump_child ("body", EH_SPEC_STMTS (t));
393       dump_child ("raises", EH_SPEC_RAISES (t));
394       break;
395
396     case PTRMEM_CST:
397       dump_child ("clas", PTRMEM_CST_CLASS (t));
398       dump_child ("mbr", PTRMEM_CST_MEMBER (t));
399       break;
400
401     case THROW_EXPR:
402       /* These nodes are unary, but do not have code class `1'.  */
403       dump_child ("op 0", TREE_OPERAND (t, 0));
404       break;
405
406     case AGGR_INIT_EXPR:
407       {
408         int i = 0;
409         tree arg;
410         aggr_init_expr_arg_iterator iter;
411         dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
412         dump_child ("fn", AGGR_INIT_EXPR_FN (t));
413         FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
414           {
415             char buffer[32];
416             sprintf (buffer, "%u", i);
417             dump_child (buffer, arg);
418             i++;
419           }
420         dump_child ("decl", AGGR_INIT_EXPR_SLOT (t));
421       }
422       break;
423
424     case HANDLER:
425       dump_stmt (di, t);
426       dump_child ("parm", HANDLER_PARMS (t));
427       dump_child ("body", HANDLER_BODY (t));
428       break;
429
430     case MUST_NOT_THROW_EXPR:
431       dump_stmt (di, t);
432       dump_child ("body", TREE_OPERAND (t, 0));
433       dump_child ("cond", MUST_NOT_THROW_COND (t));
434       break;
435
436     case USING_STMT:
437       dump_stmt (di, t);
438       dump_child ("nmsp", USING_STMT_NAMESPACE (t));
439       break;
440
441     case CLEANUP_STMT:
442       dump_stmt (di, t);
443       dump_child ("decl", CLEANUP_DECL (t));
444       dump_child ("expr", CLEANUP_EXPR (t));
445       dump_child ("body", CLEANUP_BODY (t));
446       break;
447
448     case IF_STMT:
449       dump_stmt (di, t);
450       dump_child ("cond", IF_COND (t));
451       dump_child ("then", THEN_CLAUSE (t));
452       dump_child ("else", ELSE_CLAUSE (t));
453       break;
454
455     case BREAK_STMT:
456     case CONTINUE_STMT:
457       dump_stmt (di, t);
458       break;
459
460     case DO_STMT:
461       dump_stmt (di, t);
462       dump_child ("body", DO_BODY (t));
463       dump_child ("cond", DO_COND (t));
464       break;
465
466     case FOR_STMT:
467       dump_stmt (di, t);
468       dump_child ("init", FOR_INIT_STMT (t));
469       dump_child ("cond", FOR_COND (t));
470       dump_child ("expr", FOR_EXPR (t));
471       dump_child ("body", FOR_BODY (t));
472       break;
473
474     case RANGE_FOR_STMT:
475       dump_stmt (di, t);
476       dump_child ("decl", RANGE_FOR_DECL (t));
477       dump_child ("expr", RANGE_FOR_EXPR (t));
478       dump_child ("body", RANGE_FOR_BODY (t));
479       break;
480
481     case SWITCH_STMT:
482       dump_stmt (di, t);
483       dump_child ("cond", SWITCH_STMT_COND (t));
484       dump_child ("body", SWITCH_STMT_BODY (t));
485       break;
486
487     case WHILE_STMT:
488       dump_stmt (di, t);
489       dump_child ("cond", WHILE_COND (t));
490       dump_child ("body", WHILE_BODY (t));
491       break;
492
493     case STMT_EXPR:
494       dump_child ("stmt", STMT_EXPR_STMT (t));
495       break;
496
497     case EXPR_STMT:
498       dump_stmt (di, t);
499       dump_child ("expr", EXPR_STMT_EXPR (t));
500       break;
501
502     default:
503       break;
504     }
505
506   return c_dump_tree (di, t);
507 }