1 /* Prints out tree in human readable form - GCC
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
19
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "tree.h"
26 #include "cgraph.h"
27 #include "diagnostic.h"
28 #include "varasm.h"
29 #include "print-rtl.h"
30 #include "stor-layout.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
33 #include "gimple-pretty-print.h" /* FIXME */
34 #include "tree-cfg.h"
35 #include "dumpfile.h"
36 #include "print-tree.h"
37
38 /* Define the hash table of nodes already seen.
39 Such nodes are not repeated; brief cross-references are used. */
40
41 #define HASH_SIZE 37
42
43 static hash_set<tree> *table = NULL;
44
45 /* Print PREFIX and ADDR to FILE. */
46 void
dump_addr(FILE * file,const char * prefix,const void * addr)47 dump_addr (FILE *file, const char *prefix, const void *addr)
48 {
49 if (flag_dump_noaddr || flag_dump_unnumbered)
50 fprintf (file, "%s#", prefix);
51 else
52 fprintf (file, "%s" HOST_PTR_PRINTF, prefix, addr);
53 }
54
55 /* Print to FILE a NODE representing a REAL_CST constant, including
56 Infinity and NaN. Be verbose when BFRIEF is false. */
57
58 static void
print_real_cst(FILE * file,const_tree node,bool brief)59 print_real_cst (FILE *file, const_tree node, bool brief)
60 {
61 if (TREE_OVERFLOW (node))
62 fprintf (file, " overflow");
63
64 REAL_VALUE_TYPE d = TREE_REAL_CST (node);
65 if (REAL_VALUE_ISINF (d))
66 fprintf (file, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
67 else if (REAL_VALUE_ISNAN (d))
68 {
69 /* Print a NaN in the format [-][Q]NaN[(significand[exponent])]
70 where significand is a hexadecimal string that starts with
71 the 0x prefix followed by 0 if the number is not canonical
72 and a non-zero digit if it is, and exponent is decimal. */
73 unsigned start = 0;
74 const char *psig = (const char *) d.sig;
75 for (unsigned i = 0; i != sizeof d.sig; ++i)
76 if (psig[i])
77 {
78 start = i;
79 break;
80 }
81
82 fprintf (file, " %s%sNaN", d.sign ? "-" : "",
83 d.signalling ? "S" : "Q");
84
85 if (brief)
86 return;
87
88 if (start)
89 fprintf (file, "(0x%s", d.canonical ? "" : "0");
90 else if (d.uexp)
91 fprintf (file, "(%s", d.canonical ? "" : "0");
92 else if (!d.canonical)
93 {
94 fprintf (file, "(0)");
95 return;
96 }
97
98 if (psig[start])
99 {
100 for (unsigned i = start; i != sizeof d.sig; ++i)
101 if (i == start)
102 fprintf (file, "%x", psig[i]);
103 else
104 fprintf (file, "%02x", psig[i]);
105 }
106
107 if (d.uexp)
108 fprintf (file, "%se%u)", psig[start] ? "," : "", d.uexp);
109 else if (psig[start])
110 fputc (')', file);
111 }
112 else
113 {
114 char string[64];
115 real_to_decimal (string, &d, sizeof (string), 0, 1);
116 fprintf (file, " %s", string);
117 }
118 }
119
120 /* Print a node in brief fashion, with just the code, address and name. */
121
122 void
print_node_brief(FILE * file,const char * prefix,const_tree node,int indent)123 print_node_brief (FILE *file, const char *prefix, const_tree node, int indent)
124 {
125 enum tree_code_class tclass;
126
127 if (node == 0)
128 return;
129
130 tclass = TREE_CODE_CLASS (TREE_CODE (node));
131
132 /* Always print the slot this node is in, and its code, address and
133 name if any. */
134 if (indent > 0)
135 fprintf (file, " ");
136 fprintf (file, "%s <%s", prefix, get_tree_code_name (TREE_CODE (node)));
137 dump_addr (file, " ", node);
138
139 if (tclass == tcc_declaration)
140 {
141 if (DECL_NAME (node))
142 fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
143 else if (TREE_CODE (node) == LABEL_DECL
144 && LABEL_DECL_UID (node) != -1)
145 {
146 if (dump_flags & TDF_NOUID)
147 fprintf (file, " L.xxxx");
148 else
149 fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
150 }
151 else
152 {
153 if (dump_flags & TDF_NOUID)
154 fprintf (file, " %c.xxxx",
155 TREE_CODE (node) == CONST_DECL ? 'C' : 'D');
156 else
157 fprintf (file, " %c.%u",
158 TREE_CODE (node) == CONST_DECL ? 'C' : 'D',
159 DECL_UID (node));
160 }
161 }
162 else if (tclass == tcc_type)
163 {
164 if (TYPE_NAME (node))
165 {
166 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
167 fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
168 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
169 && DECL_NAME (TYPE_NAME (node)))
170 fprintf (file, " %s",
171 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
172 }
173 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
174 fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node));
175 }
176 if (TREE_CODE (node) == IDENTIFIER_NODE)
177 fprintf (file, " %s", IDENTIFIER_POINTER (node));
178
179 /* We might as well always print the value of an integer or real. */
180 if (TREE_CODE (node) == INTEGER_CST)
181 {
182 if (TREE_OVERFLOW (node))
183 fprintf (file, " overflow");
184
185 fprintf (file, " ");
186 print_dec (wi::to_wide (node), file, TYPE_SIGN (TREE_TYPE (node)));
187 }
188 if (TREE_CODE (node) == REAL_CST)
189 print_real_cst (file, node, true);
190 if (TREE_CODE (node) == FIXED_CST)
191 {
192 FIXED_VALUE_TYPE f;
193 char string[60];
194
195 if (TREE_OVERFLOW (node))
196 fprintf (file, " overflow");
197
198 f = TREE_FIXED_CST (node);
199 fixed_to_decimal (string, &f, sizeof (string));
200 fprintf (file, " %s", string);
201 }
202
203 fprintf (file, ">");
204 }
205
206 void
indent_to(FILE * file,int column)207 indent_to (FILE *file, int column)
208 {
209 int i;
210
211 /* Since this is the long way, indent to desired column. */
212 if (column > 0)
213 fprintf (file, "\n");
214 for (i = 0; i < column; i++)
215 fprintf (file, " ");
216 }
217
218 /* Print the node NODE in full on file FILE, preceded by PREFIX,
219 starting in column INDENT. */
220
221 void
print_node(FILE * file,const char * prefix,tree node,int indent,bool brief_for_visited)222 print_node (FILE *file, const char *prefix, tree node, int indent,
223 bool brief_for_visited)
224 {
225 machine_mode mode;
226 enum tree_code_class tclass;
227 int len;
228 int i;
229 expanded_location xloc;
230 enum tree_code code;
231
232 if (node == 0)
233 return;
234
235 code = TREE_CODE (node);
236
237 /* It is unsafe to look at any other fields of a node with ERROR_MARK or
238 invalid code. */
239 if (code == ERROR_MARK || code >= MAX_TREE_CODES)
240 {
241 print_node_brief (file, prefix, node, indent);
242 return;
243 }
244
245 tclass = TREE_CODE_CLASS (code);
246
247 /* Don't get too deep in nesting. If the user wants to see deeper,
248 it is easy to use the address of a lowest-level node
249 as an argument in another call to debug_tree. */
250
251 if (indent > 24)
252 {
253 print_node_brief (file, prefix, node, indent);
254 return;
255 }
256
257 if (indent > 8 && (tclass == tcc_type || tclass == tcc_declaration))
258 {
259 print_node_brief (file, prefix, node, indent);
260 return;
261 }
262
263 /* Allow this function to be called if the table is not there. */
264 if (table)
265 {
266 /* If node is in the table, just mention its address. */
267 if (table->contains (node) && brief_for_visited)
268 {
269 print_node_brief (file, prefix, node, indent);
270 return;
271 }
272
273 table->add (node);
274 }
275
276 /* Indent to the specified column, since this is the long form. */
277 indent_to (file, indent);
278
279 /* Print the slot this node is in, and its code, and address. */
280 fprintf (file, "%s <%s", prefix, get_tree_code_name (code));
281 dump_addr (file, " ", node);
282
283 /* Print the name, if any. */
284 if (tclass == tcc_declaration)
285 {
286 if (DECL_NAME (node))
287 fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
288 else if (code == LABEL_DECL
289 && LABEL_DECL_UID (node) != -1)
290 {
291 if (dump_flags & TDF_NOUID)
292 fprintf (file, " L.xxxx");
293 else
294 fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
295 }
296 else
297 {
298 if (dump_flags & TDF_NOUID)
299 fprintf (file, " %c.xxxx", code == CONST_DECL ? 'C' : 'D');
300 else
301 fprintf (file, " %c.%u", code == CONST_DECL ? 'C' : 'D',
302 DECL_UID (node));
303 }
304 }
305 else if (tclass == tcc_type)
306 {
307 if (TYPE_NAME (node))
308 {
309 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
310 fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
311 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
312 && DECL_NAME (TYPE_NAME (node)))
313 fprintf (file, " %s",
314 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
315 }
316 }
317 if (code == IDENTIFIER_NODE)
318 fprintf (file, " %s", IDENTIFIER_POINTER (node));
319
320 if (code == INTEGER_CST)
321 {
322 if (indent <= 4)
323 print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
324 }
325 else if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
326 {
327 print_node (file, "type", TREE_TYPE (node), indent + 4);
328 if (TREE_TYPE (node))
329 indent_to (file, indent + 3);
330 }
331
332 if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node))
333 fputs (" side-effects", file);
334
335 if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node))
336 fputs (" readonly", file);
337 if (TYPE_P (node) && TYPE_ATOMIC (node))
338 fputs (" atomic", file);
339 if (!TYPE_P (node) && TREE_CONSTANT (node))
340 fputs (" constant", file);
341 else if (TYPE_P (node) && TYPE_SIZES_GIMPLIFIED (node))
342 fputs (" sizes-gimplified", file);
343
344 if (TYPE_P (node) && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
345 fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node));
346
347 if (TREE_ADDRESSABLE (node))
348 fputs (" addressable", file);
349 if (TREE_THIS_VOLATILE (node))
350 fputs (" volatile", file);
351 if (TREE_ASM_WRITTEN (node))
352 fputs (" asm_written", file);
353 if (TREE_USED (node))
354 fputs (" used", file);
355 if (TREE_NOTHROW (node))
356 fputs (" nothrow", file);
357 if (TREE_PUBLIC (node))
358 fputs (" public", file);
359 if (TREE_PRIVATE (node))
360 fputs (" private", file);
361 if (TREE_PROTECTED (node))
362 fputs (" protected", file);
363 if (TREE_STATIC (node))
364 fputs (code == CALL_EXPR ? " must-tail-call" : " static", file);
365 if (TREE_DEPRECATED (node))
366 fputs (" deprecated", file);
367 if (TREE_VISITED (node))
368 fputs (" visited", file);
369
370 if (code != TREE_VEC && code != INTEGER_CST && code != SSA_NAME)
371 {
372 if (TREE_LANG_FLAG_0 (node))
373 fputs (" tree_0", file);
374 if (TREE_LANG_FLAG_1 (node))
375 fputs (" tree_1", file);
376 if (TREE_LANG_FLAG_2 (node))
377 fputs (" tree_2", file);
378 if (TREE_LANG_FLAG_3 (node))
379 fputs (" tree_3", file);
380 if (TREE_LANG_FLAG_4 (node))
381 fputs (" tree_4", file);
382 if (TREE_LANG_FLAG_5 (node))
383 fputs (" tree_5", file);
384 if (TREE_LANG_FLAG_6 (node))
385 fputs (" tree_6", file);
386 }
387
388 /* DECL_ nodes have additional attributes. */
389
390 switch (TREE_CODE_CLASS (code))
391 {
392 case tcc_declaration:
393 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
394 {
395 if (DECL_UNSIGNED (node))
396 fputs (" unsigned", file);
397 if (DECL_IGNORED_P (node))
398 fputs (" ignored", file);
399 if (DECL_ABSTRACT_P (node))
400 fputs (" abstract", file);
401 if (DECL_EXTERNAL (node))
402 fputs (" external", file);
403 if (DECL_NONLOCAL (node))
404 fputs (" nonlocal", file);
405 }
406 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
407 {
408 if (DECL_WEAK (node))
409 fputs (" weak", file);
410 if (DECL_IN_SYSTEM_HEADER (node))
411 fputs (" in_system_header", file);
412 }
413 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)
414 && code != LABEL_DECL
415 && code != FUNCTION_DECL
416 && DECL_REGISTER (node))
417 fputs (" regdecl", file);
418
419 if (code == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
420 fputs (" suppress-debug", file);
421
422 if (code == FUNCTION_DECL
423 && DECL_FUNCTION_SPECIFIC_TARGET (node))
424 fputs (" function-specific-target", file);
425 if (code == FUNCTION_DECL
426 && DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node))
427 fputs (" function-specific-opt", file);
428 if (code == FUNCTION_DECL && DECL_DECLARED_INLINE_P (node))
429 fputs (" autoinline", file);
430 if (code == FUNCTION_DECL && DECL_UNINLINABLE (node))
431 fputs (" uninlinable", file);
432 if (code == FUNCTION_DECL && fndecl_built_in_p (node))
433 fputs (" built-in", file);
434 if (code == FUNCTION_DECL && DECL_STATIC_CHAIN (node))
435 fputs (" static-chain", file);
436 if (TREE_CODE (node) == FUNCTION_DECL && decl_is_tm_clone (node))
437 fputs (" tm-clone", file);
438
439 if (code == FIELD_DECL && DECL_PACKED (node))
440 fputs (" packed", file);
441 if (code == FIELD_DECL && DECL_BIT_FIELD (node))
442 fputs (" bit-field", file);
443 if (code == FIELD_DECL && DECL_NONADDRESSABLE_P (node))
444 fputs (" nonaddressable", file);
445
446 if (code == LABEL_DECL && EH_LANDING_PAD_NR (node))
447 fprintf (file, " landing-pad:%d", EH_LANDING_PAD_NR (node));
448
449 if (code == VAR_DECL && DECL_IN_TEXT_SECTION (node))
450 fputs (" in-text-section", file);
451 if (code == VAR_DECL && DECL_IN_CONSTANT_POOL (node))
452 fputs (" in-constant-pool", file);
453 if (code == VAR_DECL && DECL_COMMON (node))
454 fputs (" common", file);
455 if ((code == VAR_DECL || code == PARM_DECL) && DECL_READ_P (node))
456 fputs (" read", file);
457 if (code == VAR_DECL && DECL_THREAD_LOCAL_P (node))
458 {
459 fputs (" ", file);
460 fputs (tls_model_names[DECL_TLS_MODEL (node)], file);
461 }
462
463 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
464 {
465 if (DECL_VIRTUAL_P (node))
466 fputs (" virtual", file);
467 if (DECL_PRESERVE_P (node))
468 fputs (" preserve", file);
469 if (DECL_LANG_FLAG_0 (node))
470 fputs (" decl_0", file);
471 if (DECL_LANG_FLAG_1 (node))
472 fputs (" decl_1", file);
473 if (DECL_LANG_FLAG_2 (node))
474 fputs (" decl_2", file);
475 if (DECL_LANG_FLAG_3 (node))
476 fputs (" decl_3", file);
477 if (DECL_LANG_FLAG_4 (node))
478 fputs (" decl_4", file);
479 if (DECL_LANG_FLAG_5 (node))
480 fputs (" decl_5", file);
481 if (DECL_LANG_FLAG_6 (node))
482 fputs (" decl_6", file);
483 if (DECL_LANG_FLAG_7 (node))
484 fputs (" decl_7", file);
485
486 mode = DECL_MODE (node);
487 fprintf (file, " %s", GET_MODE_NAME (mode));
488 }
489
490 if ((code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
491 && DECL_BY_REFERENCE (node))
492 fputs (" passed-by-reference", file);
493
494 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS) && DECL_DEFER_OUTPUT (node))
495 fputs (" defer-output", file);
496
497
498 xloc = expand_location (DECL_SOURCE_LOCATION (node));
499 fprintf (file, " %s:%d:%d", xloc.file, xloc.line,
500 xloc.column);
501
502 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
503 {
504 print_node (file, "size", DECL_SIZE (node), indent + 4);
505 print_node (file, "unit-size", DECL_SIZE_UNIT (node), indent + 4);
506
507 if (code != FUNCTION_DECL || fndecl_built_in_p (node))
508 indent_to (file, indent + 3);
509
510 if (DECL_USER_ALIGN (node))
511 fprintf (file, " user");
512
513 fprintf (file, " align:%d warn_if_not_align:%d",
514 DECL_ALIGN (node), DECL_WARN_IF_NOT_ALIGN (node));
515 if (code == FIELD_DECL)
516 fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED,
517 DECL_OFFSET_ALIGN (node));
518
519 if (code == FUNCTION_DECL && fndecl_built_in_p (node))
520 {
521 if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)
522 fprintf (file, " built-in: BUILT_IN_MD:%d",
523 DECL_MD_FUNCTION_CODE (node));
524 else if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_FRONTEND)
525 fprintf (file, " built-in: BUILT_IN_FRONTEND:%d",
526 DECL_FE_FUNCTION_CODE (node));
527 else
528 fprintf (file, " built-in: %s:%s",
529 built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],
530 built_in_names[(int) DECL_FUNCTION_CODE (node)]);
531 }
532 }
533 if (code == FIELD_DECL)
534 {
535 print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4);
536 print_node (file, "bit-offset", DECL_FIELD_BIT_OFFSET (node),
537 indent + 4);
538 if (DECL_BIT_FIELD_TYPE (node))
539 print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node),
540 indent + 4);
541 }
542
543 print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
544
545 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
546 {
547 print_node (file, "attributes",
548 DECL_ATTRIBUTES (node), indent + 4);
549 if (code != PARM_DECL)
550 print_node_brief (file, "initial", DECL_INITIAL (node),
551 indent + 4);
552 }
553 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
554 {
555 print_node_brief (file, "abstract_origin",
556 DECL_ABSTRACT_ORIGIN (node), indent + 4);
557 }
558 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
559 {
560 print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
561 }
562
563 lang_hooks.print_decl (file, node, indent);
564
565 if (DECL_RTL_SET_P (node))
566 {
567 indent_to (file, indent + 4);
568 print_rtl (file, DECL_RTL (node));
569 }
570
571 if (code == PARM_DECL)
572 {
573 print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4);
574
575 if (DECL_INCOMING_RTL (node) != 0)
576 {
577 indent_to (file, indent + 4);
578 fprintf (file, "incoming-rtl ");
579 print_rtl (file, DECL_INCOMING_RTL (node));
580 }
581 }
582 else if (code == FUNCTION_DECL
583 && DECL_STRUCT_FUNCTION (node) != 0)
584 {
585 print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
586 indent_to (file, indent + 4);
587 dump_addr (file, "struct-function ", DECL_STRUCT_FUNCTION (node));
588 }
589
590 if ((code == VAR_DECL || code == PARM_DECL)
591 && DECL_HAS_VALUE_EXPR_P (node))
592 print_node (file, "value-expr", DECL_VALUE_EXPR (node), indent + 4);
593
594 /* Print the decl chain only if decl is at second level. */
595 if (indent == 4)
596 print_node (file, "chain", TREE_CHAIN (node), indent + 4);
597 else
598 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
599 break;
600
601 case tcc_type:
602 if (TYPE_UNSIGNED (node))
603 fputs (" unsigned", file);
604
605 if (TYPE_NO_FORCE_BLK (node))
606 fputs (" no-force-blk", file);
607
608 if (code == ARRAY_TYPE && TYPE_STRING_FLAG (node))
609 fputs (" string-flag", file);
610
611 if (TYPE_NEEDS_CONSTRUCTING (node))
612 fputs (" needs-constructing", file);
613
614 if ((code == RECORD_TYPE
615 || code == UNION_TYPE
616 || code == QUAL_UNION_TYPE
617 || code == ARRAY_TYPE)
618 && TYPE_REVERSE_STORAGE_ORDER (node))
619 fputs (" reverse-storage-order", file);
620
621 if ((code == RECORD_TYPE
622 || code == UNION_TYPE)
623 && TYPE_CXX_ODR_P (node))
624 fputs (" cxx-odr-p", file);
625
626 /* The transparent-union flag is used for different things in
627 different nodes. */
628 if ((code == UNION_TYPE || code == RECORD_TYPE)
629 && TYPE_TRANSPARENT_AGGR (node))
630 fputs (" transparent-aggr", file);
631 else if (code == ARRAY_TYPE
632 && TYPE_NONALIASED_COMPONENT (node))
633 fputs (" nonaliased-component", file);
634
635 if (TYPE_PACKED (node))
636 fputs (" packed", file);
637
638 if (TYPE_RESTRICT (node))
639 fputs (" restrict", file);
640
641 if (TYPE_LANG_FLAG_0 (node))
642 fputs (" type_0", file);
643 if (TYPE_LANG_FLAG_1 (node))
644 fputs (" type_1", file);
645 if (TYPE_LANG_FLAG_2 (node))
646 fputs (" type_2", file);
647 if (TYPE_LANG_FLAG_3 (node))
648 fputs (" type_3", file);
649 if (TYPE_LANG_FLAG_4 (node))
650 fputs (" type_4", file);
651 if (TYPE_LANG_FLAG_5 (node))
652 fputs (" type_5", file);
653 if (TYPE_LANG_FLAG_6 (node))
654 fputs (" type_6", file);
655 if (TYPE_LANG_FLAG_7 (node))
656 fputs (" type_7", file);
657
658 mode = TYPE_MODE (node);
659 fprintf (file, " %s", GET_MODE_NAME (mode));
660
661 print_node (file, "size", TYPE_SIZE (node), indent + 4);
662 print_node (file, "unit-size", TYPE_SIZE_UNIT (node), indent + 4);
663 indent_to (file, indent + 3);
664
665 if (TYPE_USER_ALIGN (node))
666 fprintf (file, " user");
667
668 fprintf (file, " align:%d warn_if_not_align:%d symtab:%d alias-set "
669 HOST_WIDE_INT_PRINT_DEC,
670 TYPE_ALIGN (node), TYPE_WARN_IF_NOT_ALIGN (node),
671 TYPE_SYMTAB_ADDRESS (node),
672 (HOST_WIDE_INT) TYPE_ALIAS_SET (node));
673
674 if (TYPE_STRUCTURAL_EQUALITY_P (node))
675 fprintf (file, " structural-equality");
676 else
677 dump_addr (file, " canonical-type ", TYPE_CANONICAL (node));
678
679 print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);
680
681 if (INTEGRAL_TYPE_P (node) || code == REAL_TYPE
682 || code == FIXED_POINT_TYPE)
683 {
684 fprintf (file, " precision:%d", TYPE_PRECISION (node));
685 print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4);
686 print_node_brief (file, "max", TYPE_MAX_VALUE (node), indent + 4);
687 }
688
689 if (code == ENUMERAL_TYPE)
690 print_node (file, "values", TYPE_VALUES (node), indent + 4);
691 else if (code == ARRAY_TYPE)
692 print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
693 else if (code == VECTOR_TYPE)
694 {
695 fprintf (file, " nunits:");
696 print_dec (TYPE_VECTOR_SUBPARTS (node), file);
697 }
698 else if (code == RECORD_TYPE
699 || code == UNION_TYPE
700 || code == QUAL_UNION_TYPE)
701 print_node (file, "fields", TYPE_FIELDS (node), indent + 4);
702 else if (code == FUNCTION_TYPE
703 || code == METHOD_TYPE)
704 {
705 if (TYPE_METHOD_BASETYPE (node))
706 print_node_brief (file, "method basetype",
707 TYPE_METHOD_BASETYPE (node), indent + 4);
708 print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4);
709 }
710 else if (code == OFFSET_TYPE)
711 print_node_brief (file, "basetype", TYPE_OFFSET_BASETYPE (node),
712 indent + 4);
713
714 if (TYPE_CONTEXT (node))
715 print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
716
717 lang_hooks.print_type (file, node, indent);
718
719 if (TYPE_POINTER_TO (node) || TREE_CHAIN (node))
720 indent_to (file, indent + 3);
721
722 print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node),
723 indent + 4);
724 print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node),
725 indent + 4);
726 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
727 break;
728
729 case tcc_expression:
730 case tcc_comparison:
731 case tcc_unary:
732 case tcc_binary:
733 case tcc_reference:
734 case tcc_statement:
735 case tcc_vl_exp:
736 if (code == BIND_EXPR)
737 {
738 print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
739 print_node (file, "body", TREE_OPERAND (node, 1), indent + 4);
740 print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
741 break;
742 }
743 if (code == CALL_EXPR)
744 {
745 call_expr_arg_iterator iter;
746 tree arg;
747 print_node (file, "fn", CALL_EXPR_FN (node), indent + 4);
748 print_node (file, "static_chain", CALL_EXPR_STATIC_CHAIN (node),
749 indent + 4);
750 i = 0;
751 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
752 {
753 /* Buffer big enough to format a 32-bit UINT_MAX into, plus
754 the text. */
755 char temp[15];
756 sprintf (temp, "arg:%u", i);
757 print_node (file, temp, arg, indent + 4);
758 i++;
759 }
760 }
761 else
762 {
763 len = TREE_OPERAND_LENGTH (node);
764
765 for (i = 0; i < len; i++)
766 {
767 /* Buffer big enough to format a 32-bit UINT_MAX into, plus
768 the text. */
769 char temp[15];
770
771 sprintf (temp, "arg:%d", i);
772 print_node (file, temp, TREE_OPERAND (node, i), indent + 4);
773 }
774 }
775 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
776 print_node (file, "chain", TREE_CHAIN (node), indent + 4);
777 break;
778
779 case tcc_constant:
780 case tcc_exceptional:
781 switch (code)
782 {
783 case INTEGER_CST:
784 if (TREE_OVERFLOW (node))
785 fprintf (file, " overflow");
786
787 fprintf (file, " ");
788 print_dec (wi::to_wide (node), file, TYPE_SIGN (TREE_TYPE (node)));
789 break;
790
791 case REAL_CST:
792 print_real_cst (file, node, false);
793 break;
794
795 case FIXED_CST:
796 {
797 FIXED_VALUE_TYPE f;
798 char string[64];
799
800 if (TREE_OVERFLOW (node))
801 fprintf (file, " overflow");
802
803 f = TREE_FIXED_CST (node);
804 fixed_to_decimal (string, &f, sizeof (string));
805 fprintf (file, " %s", string);
806 }
807 break;
808
809 case VECTOR_CST:
810 {
811 /* Big enough for UINT_MAX plus the string below. */
812 char buf[32];
813
814 fprintf (file, " npatterns:%u nelts-per-pattern:%u",
815 VECTOR_CST_NPATTERNS (node),
816 VECTOR_CST_NELTS_PER_PATTERN (node));
817 unsigned int count = vector_cst_encoded_nelts (node);
818 for (unsigned int i = 0; i < count; ++i)
819 {
820 sprintf (buf, "elt:%u: ", i);
821 print_node (file, buf, VECTOR_CST_ENCODED_ELT (node, i),
822 indent + 4);
823 }
824 }
825 break;
826
827 case COMPLEX_CST:
828 print_node (file, "real", TREE_REALPART (node), indent + 4);
829 print_node (file, "imag", TREE_IMAGPART (node), indent + 4);
830 break;
831
832 case STRING_CST:
833 {
834 const char *p = TREE_STRING_POINTER (node);
835 int i = TREE_STRING_LENGTH (node);
836 fputs (" \"", file);
837 while (--i >= 0)
838 {
839 char ch = *p++;
840 if (ch >= ' ' && ch < 127)
841 putc (ch, file);
842 else
843 fprintf (file, "\\%03o", ch & 0xFF);
844 }
845 fputc ('\"', file);
846 }
847 break;
848
849 case POLY_INT_CST:
850 {
851 char buf[10];
852 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
853 {
854 snprintf (buf, sizeof (buf), "elt%u: ", i);
855 print_node (file, buf, POLY_INT_CST_COEFF (node, i),
856 indent + 4);
857 }
858 }
859 break;
860
861 case IDENTIFIER_NODE:
862 lang_hooks.print_identifier (file, node, indent);
863 break;
864
865 case TREE_LIST:
866 print_node (file, "purpose", TREE_PURPOSE (node), indent + 4);
867 print_node (file, "value", TREE_VALUE (node), indent + 4);
868 print_node (file, "chain", TREE_CHAIN (node), indent + 4);
869 break;
870
871 case TREE_VEC:
872 len = TREE_VEC_LENGTH (node);
873 fprintf (file, " length:%d", len);
874 for (i = 0; i < len; i++)
875 if (TREE_VEC_ELT (node, i))
876 {
877 /* Buffer big enough to format a 32-bit UINT_MAX into, plus
878 the text. */
879 char temp[15];
880 sprintf (temp, "elt:%d", i);
881 print_node (file, temp, TREE_VEC_ELT (node, i), indent + 4);
882 }
883 break;
884
885 case CONSTRUCTOR:
886 {
887 unsigned HOST_WIDE_INT cnt;
888 tree index, value;
889 len = CONSTRUCTOR_NELTS (node);
890 fprintf (file, " length:%d", len);
891 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node),
892 cnt, index, value)
893 {
894 print_node (file, "idx", index, indent + 4, false);
895 print_node (file, "val", value, indent + 4, false);
896 }
897 }
898 break;
899
900 case STATEMENT_LIST:
901 dump_addr (file, " head ", node->stmt_list.head);
902 dump_addr (file, " tail ", node->stmt_list.tail);
903 fprintf (file, " stmts");
904 {
905 tree_stmt_iterator i;
906 for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i))
907 {
908 /* Not printing the addresses of the (not-a-tree)
909 'struct tree_stmt_list_node's. */
910 dump_addr (file, " ", tsi_stmt (i));
911 }
912 fprintf (file, "\n");
913 for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i))
914 {
915 /* Not printing the addresses of the (not-a-tree)
916 'struct tree_stmt_list_node's. */
917 print_node (file, "stmt", tsi_stmt (i), indent + 4);
918 }
919 }
920 break;
921
922 case BLOCK:
923 print_node (file, "vars", BLOCK_VARS (node), indent + 4);
924 print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node),
925 indent + 4);
926 print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4);
927 print_node (file, "chain", BLOCK_CHAIN (node), indent + 4);
928 print_node (file, "abstract_origin",
929 BLOCK_ABSTRACT_ORIGIN (node), indent + 4);
930 break;
931
932 case SSA_NAME:
933 print_node_brief (file, "var", SSA_NAME_VAR (node), indent + 4);
934 indent_to (file, indent + 4);
935 fprintf (file, "def_stmt ");
936 {
937 pretty_printer buffer;
938 buffer.buffer->stream = file;
939 pp_gimple_stmt_1 (&buffer, SSA_NAME_DEF_STMT (node), indent + 4,
940 TDF_NONE);
941 pp_flush (&buffer);
942 }
943
944 indent_to (file, indent + 4);
945 fprintf (file, "version:%u", SSA_NAME_VERSION (node));
946 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
947 fprintf (file, " in-abnormal-phi");
948 if (SSA_NAME_IN_FREE_LIST (node))
949 fprintf (file, " in-free-list");
950
951 if (SSA_NAME_PTR_INFO (node))
952 {
953 indent_to (file, indent + 3);
954 if (SSA_NAME_PTR_INFO (node))
955 dump_addr (file, " ptr-info ", SSA_NAME_PTR_INFO (node));
956 }
957 break;
958
959 case OMP_CLAUSE:
960 {
961 int i;
962 fprintf (file, " %s",
963 omp_clause_code_name[OMP_CLAUSE_CODE (node)]);
964 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (node)]; i++)
965 {
966 indent_to (file, indent + 4);
967 fprintf (file, "op-%d:", i);
968 print_node_brief (file, "", OMP_CLAUSE_OPERAND (node, i), 0);
969 }
970 }
971 break;
972
973 case OPTIMIZATION_NODE:
974 cl_optimization_print (file, indent + 4, TREE_OPTIMIZATION (node));
975 break;
976
977 case TARGET_OPTION_NODE:
978 cl_target_option_print (file, indent + 4, TREE_TARGET_OPTION (node));
979 break;
980 case IMPORTED_DECL:
981 fprintf (file, " imported-declaration");
982 print_node_brief (file, "associated-declaration",
983 IMPORTED_DECL_ASSOCIATED_DECL (node),
984 indent + 4);
985 break;
986
987 case TREE_BINFO:
988 fprintf (file, " bases:%d",
989 vec_safe_length (BINFO_BASE_BINFOS (node)));
990 print_node_brief (file, "offset", BINFO_OFFSET (node), indent + 4);
991 print_node_brief (file, "virtuals", BINFO_VIRTUALS (node),
992 indent + 4);
993 print_node_brief (file, "inheritance-chain",
994 BINFO_INHERITANCE_CHAIN (node),
995 indent + 4);
996 break;
997
998 default:
999 if (EXCEPTIONAL_CLASS_P (node))
1000 lang_hooks.print_xnode (file, node, indent);
1001 break;
1002 }
1003
1004 break;
1005 }
1006
1007 if (EXPR_HAS_LOCATION (node))
1008 {
1009 expanded_location xloc = expand_location (EXPR_LOCATION (node));
1010 indent_to (file, indent+4);
1011 fprintf (file, "%s:%d:%d", xloc.file, xloc.line, xloc.column);
1012
1013 /* Print the range, if any */
1014 source_range r = EXPR_LOCATION_RANGE (node);
1015 if (r.m_start)
1016 {
1017 xloc = expand_location (r.m_start);
1018 fprintf (file, " start: %s:%d:%d", xloc.file, xloc.line, xloc.column);
1019 }
1020 else
1021 {
1022 fprintf (file, " start: unknown");
1023 }
1024 if (r.m_finish)
1025 {
1026 xloc = expand_location (r.m_finish);
1027 fprintf (file, " finish: %s:%d:%d", xloc.file, xloc.line, xloc.column);
1028 }
1029 else
1030 {
1031 fprintf (file, " finish: unknown");
1032 }
1033 }
1034
1035 fprintf (file, ">");
1036 }
1037
1038 /* Print the identifier for DECL according to FLAGS. */
1039
1040 void
print_decl_identifier(FILE * file,tree decl,int flags)1041 print_decl_identifier (FILE *file, tree decl, int flags)
1042 {
1043 bool needs_colon = false;
1044 const char *name;
1045 char c;
1046
1047 if (flags & PRINT_DECL_ORIGIN)
1048 {
1049 if (DECL_IS_BUILTIN (decl))
1050 fputs ("<built-in>", file);
1051 else
1052 {
1053 expanded_location loc
1054 = expand_location (DECL_SOURCE_LOCATION (decl));
1055 fprintf (file, "%s:%d:%d", loc.file, loc.line, loc.column);
1056 }
1057 needs_colon = true;
1058 }
1059
1060 if (flags & PRINT_DECL_UNIQUE_NAME)
1061 {
1062 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1063 if (!TREE_PUBLIC (decl)
1064 || (DECL_WEAK (decl) && !DECL_EXTERNAL (decl)))
1065 /* The symbol has internal or weak linkage so its assembler name
1066 is not necessarily unique among the compilation units of the
1067 program. We therefore have to further mangle it. But we can't
1068 simply use DECL_SOURCE_FILE because it contains the name of the
1069 file the symbol originates from so, e.g. for function templates
1070 in C++ where the templates are defined in a header file, we can
1071 have symbols with the same assembler name and DECL_SOURCE_FILE.
1072 That's why we use the name of the top-level source file of the
1073 compilation unit. ??? Unnecessary for Ada. */
1074 name = ACONCAT ((main_input_filename, ":", name, NULL));
1075 }
1076 else if (flags & PRINT_DECL_NAME)
1077 {
1078 /* We don't want to print the full qualified name because it can be long,
1079 so we strip the scope prefix, but we may need to deal with the suffix
1080 created by the compiler. */
1081 const char *suffix = strchr (IDENTIFIER_POINTER (DECL_NAME (decl)), '.');
1082 name = lang_hooks.decl_printable_name (decl, 2);
1083 if (suffix)
1084 {
1085 const char *dot = strchr (name, '.');
1086 while (dot && strcasecmp (dot, suffix) != 0)
1087 {
1088 name = dot + 1;
1089 dot = strchr (name, '.');
1090 }
1091 }
1092 else
1093 {
1094 const char *dot = strrchr (name, '.');
1095 if (dot)
1096 name = dot + 1;
1097 }
1098 }
1099 else
1100 return;
1101
1102 if (needs_colon)
1103 fputc (':', file);
1104
1105 while ((c = *name++) != '\0')
1106 {
1107 /* Strip double-quotes because of VCG. */
1108 if (c == '"')
1109 continue;
1110 fputc (c, file);
1111 }
1112 }
1113
1114
1115 /* Print the node NODE on standard error, for debugging.
1116 Most nodes referred to by this one are printed recursively
1117 down to a depth of six. */
1118
1119 DEBUG_FUNCTION void
debug_tree(tree node)1120 debug_tree (tree node)
1121 {
1122 table = new hash_set<tree> (HASH_SIZE);
1123 print_node (stderr, "", node, 0);
1124 delete table;
1125 table = NULL;
1126 putc ('\n', stderr);
1127 }
1128
1129 DEBUG_FUNCTION void
debug_raw(const tree_node & ref)1130 debug_raw (const tree_node &ref)
1131 {
1132 debug_tree (const_cast <tree> (&ref));
1133 }
1134
1135 DEBUG_FUNCTION void
debug_raw(const tree_node * ptr)1136 debug_raw (const tree_node *ptr)
1137 {
1138 if (ptr)
1139 debug_raw (*ptr);
1140 else
1141 fprintf (stderr, "<nil>\n");
1142 }
1143
1144 static void
dump_tree_via_hooks(const tree_node * ptr,dump_flags_t options)1145 dump_tree_via_hooks (const tree_node *ptr, dump_flags_t options)
1146 {
1147 if (DECL_P (ptr))
1148 lang_hooks.print_decl (stderr, const_cast <tree_node*> (ptr), 0);
1149 else if (TYPE_P (ptr))
1150 lang_hooks.print_type (stderr, const_cast <tree_node*> (ptr), 0);
1151 else if (TREE_CODE (ptr) == IDENTIFIER_NODE)
1152 lang_hooks.print_identifier (stderr, const_cast <tree_node*> (ptr), 0);
1153 else
1154 print_generic_expr (stderr, const_cast <tree_node*> (ptr), options);
1155 fprintf (stderr, "\n");
1156 }
1157
1158 DEBUG_FUNCTION void
debug(const tree_node & ref)1159 debug (const tree_node &ref)
1160 {
1161 dump_tree_via_hooks (&ref, TDF_NONE);
1162 }
1163
1164 DEBUG_FUNCTION void
debug(const tree_node * ptr)1165 debug (const tree_node *ptr)
1166 {
1167 if (ptr)
1168 debug (*ptr);
1169 else
1170 fprintf (stderr, "<nil>\n");
1171 }
1172
1173 DEBUG_FUNCTION void
debug_head(const tree_node & ref)1174 debug_head (const tree_node &ref)
1175 {
1176 debug (ref);
1177 }
1178
1179 DEBUG_FUNCTION void
debug_head(const tree_node * ptr)1180 debug_head (const tree_node *ptr)
1181 {
1182 if (ptr)
1183 debug_head (*ptr);
1184 else
1185 fprintf (stderr, "<nil>\n");
1186 }
1187
1188 DEBUG_FUNCTION void
debug_body(const tree_node & ref)1189 debug_body (const tree_node &ref)
1190 {
1191 if (TREE_CODE (&ref) == FUNCTION_DECL)
1192 dump_function_to_file (const_cast <tree_node*> (&ref), stderr, TDF_NONE);
1193 else
1194 debug (ref);
1195 }
1196
1197 DEBUG_FUNCTION void
debug_body(const tree_node * ptr)1198 debug_body (const tree_node *ptr)
1199 {
1200 if (ptr)
1201 debug_body (*ptr);
1202 else
1203 fprintf (stderr, "<nil>\n");
1204 }
1205
1206 /* Print the vector of trees VEC on standard error, for debugging.
1207 Most nodes referred to by this one are printed recursively
1208 down to a depth of six. */
1209
1210 DEBUG_FUNCTION void
debug_raw(vec<tree,va_gc> & ref)1211 debug_raw (vec<tree, va_gc> &ref)
1212 {
1213 tree elt;
1214 unsigned ix;
1215
1216 /* Print the slot this node is in, and its code, and address. */
1217 fprintf (stderr, "<VEC");
1218 dump_addr (stderr, " ", ref.address ());
1219
1220 FOR_EACH_VEC_ELT (ref, ix, elt)
1221 {
1222 fprintf (stderr, "elt:%d ", ix);
1223 debug_raw (elt);
1224 }
1225 }
1226
1227 DEBUG_FUNCTION void
debug_raw(vec<tree,va_gc> * ptr)1228 debug_raw (vec<tree, va_gc> *ptr)
1229 {
1230 if (ptr)
1231 debug_raw (*ptr);
1232 else
1233 fprintf (stderr, "<nil>\n");
1234 }
1235
1236 static void
debug_slim(tree t)1237 debug_slim (tree t)
1238 {
1239 print_node_brief (stderr, "", t, 0);
1240 }
1241
1242 DEFINE_DEBUG_VEC (tree)
1243 DEFINE_DEBUG_HASH_SET (tree)
1244