1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2013 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
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/>. */
23 #include "coretypes.h"
26 #include "tree-pretty-print.h"
28 #include "tree-flow.h"
29 #include "langhooks.h"
30 #include "tree-iterator.h"
31 #include "tree-chrec.h"
33 #include "value-prof.h"
36 #include <new> // For placement-new.
38 /* Local functions, macros and variables. */
39 static const char *op_symbol (const_tree
);
40 static void pretty_print_string (pretty_printer
*, const char*);
41 static void newline_and_indent (pretty_printer
*, int);
42 static void maybe_init_pretty_print (FILE *);
43 static void print_struct_decl (pretty_printer
*, const_tree
, int, int);
44 static void do_niy (pretty_printer
*, const_tree
);
46 #define INDENT(SPACE) do { \
47 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
49 #define NIY do_niy(buffer,node)
51 static pretty_printer buffer
;
52 static int initialized
= 0;
54 /* Try to print something for an unknown tree code. */
57 do_niy (pretty_printer
*buffer
, const_tree node
)
61 pp_string (buffer
, "<<< Unknown tree: ");
62 pp_string (buffer
, tree_code_name
[(int) TREE_CODE (node
)]);
66 len
= TREE_OPERAND_LENGTH (node
);
67 for (i
= 0; i
< len
; ++i
)
69 newline_and_indent (buffer
, 2);
70 dump_generic_node (buffer
, TREE_OPERAND (node
, i
), 2, 0, false);
74 pp_string (buffer
, " >>>");
77 /* Debugging function to print out a generic expression. */
80 debug_generic_expr (tree t
)
82 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
83 fprintf (stderr
, "\n");
86 /* Debugging function to print out a generic statement. */
89 debug_generic_stmt (tree t
)
91 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
92 fprintf (stderr
, "\n");
95 /* Debugging function to print out a chain of trees . */
98 debug_tree_chain (tree t
)
100 struct pointer_set_t
*seen
= pointer_set_create ();
104 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
105 fprintf (stderr
, " ");
107 if (pointer_set_insert (seen
, t
))
109 fprintf (stderr
, "... [cycled back to ");
110 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
111 fprintf (stderr
, "]");
115 fprintf (stderr
, "\n");
117 pointer_set_destroy (seen
);
120 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
122 print_generic_decl (FILE *file
, tree decl
, int flags
)
124 maybe_init_pretty_print (file
);
125 print_declaration (&buffer
, decl
, 2, flags
);
126 pp_write_text_to_stream (&buffer
);
129 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
130 to show in the dump. See TDF_* in dumpfile.h. */
133 print_generic_stmt (FILE *file
, tree t
, int flags
)
135 maybe_init_pretty_print (file
);
136 dump_generic_node (&buffer
, t
, 0, flags
, true);
137 pp_newline_and_flush (&buffer
);
140 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
141 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
145 print_generic_stmt_indented (FILE *file
, tree t
, int flags
, int indent
)
149 maybe_init_pretty_print (file
);
151 for (i
= 0; i
< indent
; i
++)
153 dump_generic_node (&buffer
, t
, indent
, flags
, true);
154 pp_newline_and_flush (&buffer
);
157 /* Print a single expression T on file FILE. FLAGS specifies details to show
158 in the dump. See TDF_* in dumpfile.h. */
161 print_generic_expr (FILE *file
, tree t
, int flags
)
163 maybe_init_pretty_print (file
);
164 dump_generic_node (&buffer
, t
, 0, flags
, false);
168 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
172 dump_decl_name (pretty_printer
*buffer
, tree node
, int flags
)
174 if (DECL_NAME (node
))
176 if ((flags
& TDF_ASMNAME
) && DECL_ASSEMBLER_NAME_SET_P (node
))
177 pp_tree_identifier (buffer
, DECL_ASSEMBLER_NAME (node
));
179 pp_tree_identifier (buffer
, DECL_NAME (node
));
181 if ((flags
& TDF_UID
) || DECL_NAME (node
) == NULL_TREE
)
183 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
184 pp_printf (buffer
, "L.%d", (int) LABEL_DECL_UID (node
));
185 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
187 if (flags
& TDF_NOUID
)
188 pp_string (buffer
, "D#xxxx");
190 pp_printf (buffer
, "D#%i", DEBUG_TEMP_UID (node
));
194 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
195 if (flags
& TDF_NOUID
)
196 pp_printf (buffer
, "%c.xxxx", c
);
198 pp_printf (buffer
, "%c.%u", c
, DECL_UID (node
));
201 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
203 if (flags
& TDF_NOUID
)
204 pp_printf (buffer
, "ptD.xxxx");
206 pp_printf (buffer
, "ptD.%u", DECL_PT_UID (node
));
210 /* Like the above, but used for pretty printing function calls. */
213 dump_function_name (pretty_printer
*buffer
, tree node
, int flags
)
215 if (TREE_CODE (node
) == NOP_EXPR
)
216 node
= TREE_OPERAND (node
, 0);
217 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
218 pp_string (buffer
, lang_hooks
.decl_printable_name (node
, 1));
220 dump_decl_name (buffer
, node
, flags
);
223 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
224 FLAGS are as in dump_generic_node. */
227 dump_function_declaration (pretty_printer
*buffer
, tree node
,
230 bool wrote_arg
= false;
234 pp_left_paren (buffer
);
236 /* Print the argument types. */
237 arg
= TYPE_ARG_TYPES (node
);
238 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
246 dump_generic_node (buffer
, TREE_VALUE (arg
), spc
, flags
, false);
247 arg
= TREE_CHAIN (arg
);
250 /* Drop the trailing void_type_node if we had any previous argument. */
251 if (arg
== void_list_node
&& !wrote_arg
)
252 pp_string (buffer
, "void");
253 /* Properly dump vararg function types. */
254 else if (!arg
&& wrote_arg
)
255 pp_string (buffer
, ", ...");
256 /* Avoid printing any arg for unprototyped functions. */
258 pp_right_paren (buffer
);
261 /* Dump the domain associated with an array. */
264 dump_array_domain (pretty_printer
*buffer
, tree domain
, int spc
, int flags
)
266 pp_left_bracket (buffer
);
269 tree min
= TYPE_MIN_VALUE (domain
);
270 tree max
= TYPE_MAX_VALUE (domain
);
273 && integer_zerop (min
)
274 && host_integerp (max
, 0))
275 pp_wide_integer (buffer
, TREE_INT_CST_LOW (max
) + 1);
279 dump_generic_node (buffer
, min
, spc
, flags
, false);
282 dump_generic_node (buffer
, max
, spc
, flags
, false);
286 pp_string (buffer
, "<unknown>");
287 pp_right_bracket (buffer
);
291 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
292 dump_generic_node. */
295 dump_omp_clause (pretty_printer
*buffer
, tree clause
, int spc
, int flags
)
299 switch (OMP_CLAUSE_CODE (clause
))
301 case OMP_CLAUSE_PRIVATE
:
304 case OMP_CLAUSE_SHARED
:
307 case OMP_CLAUSE_FIRSTPRIVATE
:
308 name
= "firstprivate";
310 case OMP_CLAUSE_LASTPRIVATE
:
311 name
= "lastprivate";
313 case OMP_CLAUSE_COPYIN
:
316 case OMP_CLAUSE_COPYPRIVATE
:
317 name
= "copyprivate";
320 pp_string (buffer
, name
);
321 pp_left_paren (buffer
);
322 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
324 pp_right_paren (buffer
);
327 case OMP_CLAUSE_REDUCTION
:
328 pp_string (buffer
, "reduction(");
329 pp_string (buffer
, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
331 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
333 pp_right_paren (buffer
);
337 pp_string (buffer
, "if(");
338 dump_generic_node (buffer
, OMP_CLAUSE_IF_EXPR (clause
),
340 pp_right_paren (buffer
);
343 case OMP_CLAUSE_NUM_THREADS
:
344 pp_string (buffer
, "num_threads(");
345 dump_generic_node (buffer
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
347 pp_right_paren (buffer
);
350 case OMP_CLAUSE_NOWAIT
:
351 pp_string (buffer
, "nowait");
353 case OMP_CLAUSE_ORDERED
:
354 pp_string (buffer
, "ordered");
357 case OMP_CLAUSE_DEFAULT
:
358 pp_string (buffer
, "default(");
359 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
361 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
363 case OMP_CLAUSE_DEFAULT_SHARED
:
364 pp_string (buffer
, "shared");
366 case OMP_CLAUSE_DEFAULT_NONE
:
367 pp_string (buffer
, "none");
369 case OMP_CLAUSE_DEFAULT_PRIVATE
:
370 pp_string (buffer
, "private");
372 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
373 pp_string (buffer
, "firstprivate");
378 pp_right_paren (buffer
);
381 case OMP_CLAUSE_SCHEDULE
:
382 pp_string (buffer
, "schedule(");
383 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
))
385 case OMP_CLAUSE_SCHEDULE_STATIC
:
386 pp_string (buffer
, "static");
388 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
389 pp_string (buffer
, "dynamic");
391 case OMP_CLAUSE_SCHEDULE_GUIDED
:
392 pp_string (buffer
, "guided");
394 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
395 pp_string (buffer
, "runtime");
397 case OMP_CLAUSE_SCHEDULE_AUTO
:
398 pp_string (buffer
, "auto");
403 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
406 dump_generic_node (buffer
,
407 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
410 pp_right_paren (buffer
);
413 case OMP_CLAUSE_UNTIED
:
414 pp_string (buffer
, "untied");
417 case OMP_CLAUSE_COLLAPSE
:
418 pp_string (buffer
, "collapse(");
419 dump_generic_node (buffer
,
420 OMP_CLAUSE_COLLAPSE_EXPR (clause
),
422 pp_right_paren (buffer
);
425 case OMP_CLAUSE_FINAL
:
426 pp_string (buffer
, "final(");
427 dump_generic_node (buffer
, OMP_CLAUSE_FINAL_EXPR (clause
),
429 pp_right_paren (buffer
);
432 case OMP_CLAUSE_MERGEABLE
:
433 pp_string (buffer
, "mergeable");
437 /* Should never happen. */
438 dump_generic_node (buffer
, clause
, spc
, flags
, false);
444 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
445 dump_generic_node. */
448 dump_omp_clauses (pretty_printer
*buffer
, tree clause
, int spc
, int flags
)
456 dump_omp_clause (buffer
, clause
, spc
, flags
);
457 clause
= OMP_CLAUSE_CHAIN (clause
);
465 /* Dump location LOC to BUFFER. */
468 dump_location (pretty_printer
*buffer
, location_t loc
)
470 expanded_location xloc
= expand_location (loc
);
472 pp_left_bracket (buffer
);
475 pp_string (buffer
, xloc
.file
);
476 pp_string (buffer
, " : ");
478 pp_decimal_int (buffer
, xloc
.line
);
479 pp_string (buffer
, "] ");
483 /* Dump lexical block BLOCK. BUFFER, SPC and FLAGS are as in
484 dump_generic_node. */
487 dump_block_node (pretty_printer
*buffer
, tree block
, int spc
, int flags
)
491 pp_printf (buffer
, "BLOCK #%d ", BLOCK_NUMBER (block
));
493 if (flags
& TDF_ADDRESS
)
494 pp_printf (buffer
, "[%p] ", (void *) block
);
496 if (BLOCK_ABSTRACT (block
))
497 pp_string (buffer
, "[abstract] ");
499 if (TREE_ASM_WRITTEN (block
))
500 pp_string (buffer
, "[written] ");
502 if (flags
& TDF_SLIM
)
505 if (BLOCK_SOURCE_LOCATION (block
))
506 dump_location (buffer
, BLOCK_SOURCE_LOCATION (block
));
508 newline_and_indent (buffer
, spc
+ 2);
510 if (BLOCK_SUPERCONTEXT (block
))
512 pp_string (buffer
, "SUPERCONTEXT: ");
513 dump_generic_node (buffer
, BLOCK_SUPERCONTEXT (block
), 0,
514 flags
| TDF_SLIM
, false);
515 newline_and_indent (buffer
, spc
+ 2);
518 if (BLOCK_SUBBLOCKS (block
))
520 pp_string (buffer
, "SUBBLOCKS: ");
521 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
523 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
526 newline_and_indent (buffer
, spc
+ 2);
529 if (BLOCK_CHAIN (block
))
531 pp_string (buffer
, "SIBLINGS: ");
532 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
534 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
537 newline_and_indent (buffer
, spc
+ 2);
540 if (BLOCK_VARS (block
))
542 pp_string (buffer
, "VARS: ");
543 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
545 dump_generic_node (buffer
, t
, 0, flags
, false);
548 newline_and_indent (buffer
, spc
+ 2);
551 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
554 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
556 pp_string (buffer
, "NONLOCALIZED_VARS: ");
557 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
559 dump_generic_node (buffer
, t
, 0, flags
, false);
562 newline_and_indent (buffer
, spc
+ 2);
565 if (BLOCK_ABSTRACT_ORIGIN (block
))
567 pp_string (buffer
, "ABSTRACT_ORIGIN: ");
568 dump_generic_node (buffer
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
569 flags
| TDF_SLIM
, false);
570 newline_and_indent (buffer
, spc
+ 2);
573 if (BLOCK_FRAGMENT_ORIGIN (block
))
575 pp_string (buffer
, "FRAGMENT_ORIGIN: ");
576 dump_generic_node (buffer
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
577 flags
| TDF_SLIM
, false);
578 newline_and_indent (buffer
, spc
+ 2);
581 if (BLOCK_FRAGMENT_CHAIN (block
))
583 pp_string (buffer
, "FRAGMENT_CHAIN: ");
584 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
586 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
589 newline_and_indent (buffer
, spc
+ 2);
594 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
595 indent. FLAGS specifies details to show in the dump (see TDF_* in
596 dumpfile.h). If IS_STMT is true, the object printed is considered
597 to be a statement and it is terminated by ';' if appropriate. */
600 dump_generic_node (pretty_printer
*buffer
, tree node
, int spc
, int flags
,
609 if (node
== NULL_TREE
)
612 is_expr
= EXPR_P (node
);
614 if (is_stmt
&& (flags
& TDF_STMTADDR
))
615 pp_printf (buffer
, "<&%p> ", (void *)node
);
617 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
618 dump_location (buffer
, EXPR_LOCATION (node
));
620 code
= TREE_CODE (node
);
624 pp_string (buffer
, "<<< error >>>");
627 case IDENTIFIER_NODE
:
628 pp_tree_identifier (buffer
, node
);
632 while (node
&& node
!= error_mark_node
)
634 if (TREE_PURPOSE (node
))
636 dump_generic_node (buffer
, TREE_PURPOSE (node
), spc
, flags
, false);
639 dump_generic_node (buffer
, TREE_VALUE (node
), spc
, flags
, false);
640 node
= TREE_CHAIN (node
);
641 if (node
&& TREE_CODE (node
) == TREE_LIST
)
650 dump_generic_node (buffer
, BINFO_TYPE (node
), spc
, flags
, false);
656 if (TREE_VEC_LENGTH (node
) > 0)
658 size_t len
= TREE_VEC_LENGTH (node
);
659 for (i
= 0; i
< len
- 1; i
++)
661 dump_generic_node (buffer
, TREE_VEC_ELT (node
, i
), spc
, flags
,
666 dump_generic_node (buffer
, TREE_VEC_ELT (node
, len
- 1), spc
,
675 case FIXED_POINT_TYPE
:
681 unsigned int quals
= TYPE_QUALS (node
);
682 enum tree_code_class tclass
;
684 if (quals
& TYPE_QUAL_CONST
)
685 pp_string (buffer
, "const ");
686 else if (quals
& TYPE_QUAL_VOLATILE
)
687 pp_string (buffer
, "volatile ");
688 else if (quals
& TYPE_QUAL_RESTRICT
)
689 pp_string (buffer
, "restrict ");
691 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
693 pp_string (buffer
, "<address-space-");
694 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
695 pp_string (buffer
, "> ");
698 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
700 if (tclass
== tcc_declaration
)
702 if (DECL_NAME (node
))
703 dump_decl_name (buffer
, node
, flags
);
705 pp_string (buffer
, "<unnamed type decl>");
707 else if (tclass
== tcc_type
)
709 if (TYPE_NAME (node
))
711 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
712 pp_tree_identifier (buffer
, TYPE_NAME (node
));
713 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
714 && DECL_NAME (TYPE_NAME (node
)))
715 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
717 pp_string (buffer
, "<unnamed type>");
719 else if (TREE_CODE (node
) == VECTOR_TYPE
)
721 pp_string (buffer
, "vector");
722 pp_left_paren (buffer
);
723 pp_wide_integer (buffer
, TYPE_VECTOR_SUBPARTS (node
));
724 pp_string (buffer
, ") ");
725 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
727 else if (TREE_CODE (node
) == INTEGER_TYPE
)
729 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
730 pp_string (buffer
, (TYPE_UNSIGNED (node
)
733 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
734 pp_string (buffer
, (TYPE_UNSIGNED (node
)
737 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
738 pp_string (buffer
, (TYPE_UNSIGNED (node
)
741 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
742 pp_string (buffer
, (TYPE_UNSIGNED (node
)
745 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
746 pp_string (buffer
, (TYPE_UNSIGNED (node
)
747 ? "unsigned long long"
748 : "signed long long"));
749 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
750 && exact_log2 (TYPE_PRECISION (node
)) != -1)
752 pp_string (buffer
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
753 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
754 pp_string (buffer
, "_t");
758 pp_string (buffer
, (TYPE_UNSIGNED (node
)
759 ? "<unnamed-unsigned:"
760 : "<unnamed-signed:"));
761 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
765 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
767 pp_string (buffer
, "__complex__ ");
768 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
770 else if (TREE_CODE (node
) == REAL_TYPE
)
772 pp_string (buffer
, "<float:");
773 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
776 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
778 pp_string (buffer
, "<fixed-point-");
779 pp_string (buffer
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
780 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
783 else if (TREE_CODE (node
) == VOID_TYPE
)
784 pp_string (buffer
, "void");
786 pp_string (buffer
, "<unnamed type>");
793 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
795 if (TREE_TYPE (node
) == NULL
)
797 pp_string (buffer
, str
);
798 pp_string (buffer
, "<null type>");
800 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
802 tree fnode
= TREE_TYPE (node
);
804 dump_generic_node (buffer
, TREE_TYPE (fnode
), spc
, flags
, false);
806 pp_left_paren (buffer
);
807 pp_string (buffer
, str
);
808 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
809 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
810 else if (flags
& TDF_NOUID
)
811 pp_printf (buffer
, "<Txxxx>");
813 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
815 pp_right_paren (buffer
);
816 dump_function_declaration (buffer
, fnode
, spc
, flags
);
820 unsigned int quals
= TYPE_QUALS (node
);
822 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
824 pp_string (buffer
, str
);
826 if (quals
& TYPE_QUAL_CONST
)
827 pp_string (buffer
, " const");
828 if (quals
& TYPE_QUAL_VOLATILE
)
829 pp_string (buffer
, " volatile");
830 if (quals
& TYPE_QUAL_RESTRICT
)
831 pp_string (buffer
, " restrict");
833 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
835 pp_string (buffer
, " <address-space-");
836 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
840 if (TYPE_REF_CAN_ALIAS_ALL (node
))
841 pp_string (buffer
, " {ref-all}");
851 if (integer_zerop (TREE_OPERAND (node
, 1))
852 /* Dump the types of INTEGER_CSTs explicitly, for we can't
853 infer them and MEM_ATTR caching will share MEM_REFs
854 with differently-typed op0s. */
855 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
856 /* Released SSA_NAMES have no TREE_TYPE. */
857 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
858 /* Same pointer types, but ignoring POINTER_TYPE vs.
860 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
861 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
862 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
863 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
864 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
865 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
866 /* Same value types ignoring qualifiers. */
867 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
869 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))))
871 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
874 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
878 dump_generic_node (buffer
,
879 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
886 pp_string (buffer
, "MEM[");
887 pp_left_paren (buffer
);
888 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
889 dump_generic_node (buffer
, ptype
,
890 spc
, flags
| TDF_SLIM
, false);
891 pp_right_paren (buffer
);
892 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
894 if (!integer_zerop (TREE_OPERAND (node
, 1)))
896 pp_string (buffer
, " + ");
897 dump_generic_node (buffer
, TREE_OPERAND (node
, 1),
900 pp_right_bracket (buffer
);
907 const char *sep
= "";
910 pp_string (buffer
, "MEM[");
912 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
914 pp_string (buffer
, sep
);
916 pp_string (buffer
, "symbol: ");
917 dump_generic_node (buffer
, TREE_OPERAND (TMR_BASE (node
), 0),
922 pp_string (buffer
, sep
);
924 pp_string (buffer
, "base: ");
925 dump_generic_node (buffer
, TMR_BASE (node
), spc
, flags
, false);
927 tmp
= TMR_INDEX2 (node
);
930 pp_string (buffer
, sep
);
932 pp_string (buffer
, "base: ");
933 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
935 tmp
= TMR_INDEX (node
);
938 pp_string (buffer
, sep
);
940 pp_string (buffer
, "index: ");
941 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
943 tmp
= TMR_STEP (node
);
946 pp_string (buffer
, sep
);
948 pp_string (buffer
, "step: ");
949 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
951 tmp
= TMR_OFFSET (node
);
954 pp_string (buffer
, sep
);
956 pp_string (buffer
, "offset: ");
957 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
959 pp_right_bracket (buffer
);
967 /* Print the innermost component type. */
968 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
969 tmp
= TREE_TYPE (tmp
))
971 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
973 /* Print the dimensions. */
974 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
975 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
981 case QUAL_UNION_TYPE
:
983 unsigned int quals
= TYPE_QUALS (node
);
985 if (quals
& TYPE_QUAL_CONST
)
986 pp_string (buffer
, "const ");
987 if (quals
& TYPE_QUAL_VOLATILE
)
988 pp_string (buffer
, "volatile ");
990 /* Print the name of the structure. */
991 if (TREE_CODE (node
) == RECORD_TYPE
)
992 pp_string (buffer
, "struct ");
993 else if (TREE_CODE (node
) == UNION_TYPE
)
994 pp_string (buffer
, "union ");
996 if (TYPE_NAME (node
))
997 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, flags
, false);
998 else if (!(flags
& TDF_SLIM
))
999 /* FIXME: If we eliminate the 'else' above and attempt
1000 to show the fields for named types, we may get stuck
1001 following a cycle of pointers to structs. The alleged
1002 self-reference check in print_struct_decl will not detect
1003 cycles involving more than one pointer or struct type. */
1004 print_struct_decl (buffer
, node
, spc
, flags
);
1013 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
1015 /* In the case of a pointer, one may want to divide by the
1016 size of the pointed-to type. Unfortunately, this not
1017 straightforward. The C front-end maps expressions
1022 in such a way that the two INTEGER_CST nodes for "5" have
1023 different values but identical types. In the latter
1024 case, the 5 is multiplied by sizeof (int) in c-common.c
1025 (pointer_int_sum) to convert it to a byte address, and
1026 yet the type of the node is left unchanged. Argh. What
1027 is consistent though is that the number value corresponds
1028 to bytes (UNITS) offset.
1030 NB: Neither of the following divisors can be trivially
1031 used to recover the original literal:
1033 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1034 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1035 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
1036 pp_string (buffer
, "B"); /* pseudo-unit */
1038 else if (host_integerp (node
, 0))
1039 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
1040 else if (host_integerp (node
, 1))
1041 pp_unsigned_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
1045 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (val
);
1046 HOST_WIDE_INT high
= TREE_INT_CST_HIGH (val
);
1048 if (tree_int_cst_sgn (val
) < 0)
1051 high
= ~high
+ !low
;
1054 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
1056 sprintf (pp_buffer (buffer
)->digit_buffer
,
1057 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
1058 (unsigned HOST_WIDE_INT
) high
, low
);
1059 pp_string (buffer
, pp_buffer (buffer
)->digit_buffer
);
1064 /* Code copied from print_node. */
1067 if (TREE_OVERFLOW (node
))
1068 pp_string (buffer
, " overflow");
1070 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
1071 d
= TREE_REAL_CST (node
);
1072 if (REAL_VALUE_ISINF (d
))
1073 pp_string (buffer
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1074 else if (REAL_VALUE_ISNAN (d
))
1075 pp_string (buffer
, " Nan");
1079 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1080 pp_string (buffer
, string
);
1085 unsigned char *p
= (unsigned char *) &TREE_REAL_CST (node
);
1086 pp_string (buffer
, "0x");
1087 for (i
= 0; i
< sizeof TREE_REAL_CST (node
); i
++)
1088 output_formatted_integer (buffer
, "%02x", *p
++);
1097 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1098 pp_string (buffer
, string
);
1103 pp_string (buffer
, "__complex__ (");
1104 dump_generic_node (buffer
, TREE_REALPART (node
), spc
, flags
, false);
1105 pp_string (buffer
, ", ");
1106 dump_generic_node (buffer
, TREE_IMAGPART (node
), spc
, flags
, false);
1107 pp_right_paren (buffer
);
1111 pp_string (buffer
, "\"");
1112 pretty_print_string (buffer
, TREE_STRING_POINTER (node
));
1113 pp_string (buffer
, "\"");
1119 pp_string (buffer
, "{ ");
1120 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1123 pp_string (buffer
, ", ");
1124 dump_generic_node (buffer
, VECTOR_CST_ELT (node
, i
),
1127 pp_string (buffer
, " }");
1133 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1135 if (TREE_CODE (node
) == METHOD_TYPE
)
1137 if (TYPE_METHOD_BASETYPE (node
))
1138 dump_decl_name (buffer
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1141 pp_string (buffer
, "<null method basetype>");
1142 pp_colon_colon (buffer
);
1144 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1145 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
1146 else if (flags
& TDF_NOUID
)
1147 pp_printf (buffer
, "<Txxxx>");
1149 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
1150 dump_function_declaration (buffer
, node
, spc
, flags
);
1155 dump_decl_name (buffer
, node
, flags
);
1159 if (DECL_NAME (node
))
1160 dump_decl_name (buffer
, node
, flags
);
1161 else if (LABEL_DECL_UID (node
) != -1)
1162 pp_printf (buffer
, "<L%d>", (int) LABEL_DECL_UID (node
));
1165 if (flags
& TDF_NOUID
)
1166 pp_string (buffer
, "<D.xxxx>");
1168 pp_printf (buffer
, "<D.%u>", DECL_UID (node
));
1173 if (DECL_IS_BUILTIN (node
))
1175 /* Don't print the declaration of built-in types. */
1178 if (DECL_NAME (node
))
1179 dump_decl_name (buffer
, node
, flags
);
1180 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1182 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1183 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1184 && TYPE_METHODS (TREE_TYPE (node
)))
1186 /* The type is a c++ class: all structures have at least
1188 pp_string (buffer
, "class ");
1189 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1194 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1195 ? "union" : "struct "));
1196 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1200 pp_string (buffer
, "<anon>");
1206 case DEBUG_EXPR_DECL
:
1207 case NAMESPACE_DECL
:
1208 dump_decl_name (buffer
, node
, flags
);
1212 pp_string (buffer
, "<retval>");
1216 op0
= TREE_OPERAND (node
, 0);
1219 && (TREE_CODE (op0
) == INDIRECT_REF
1220 || (TREE_CODE (op0
) == MEM_REF
1221 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1222 && integer_zerop (TREE_OPERAND (op0
, 1))
1223 /* Dump the types of INTEGER_CSTs explicitly, for we
1224 can't infer them and MEM_ATTR caching will share
1225 MEM_REFs with differently-typed op0s. */
1226 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1227 /* Released SSA_NAMES have no TREE_TYPE. */
1228 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1229 /* Same pointer types, but ignoring POINTER_TYPE vs.
1231 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1232 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1233 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1234 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1235 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1236 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1237 /* Same value types ignoring qualifiers. */
1238 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1239 == TYPE_MAIN_VARIANT
1240 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))))))
1242 op0
= TREE_OPERAND (op0
, 0);
1245 if (op_prio (op0
) < op_prio (node
))
1246 pp_left_paren (buffer
);
1247 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1248 if (op_prio (op0
) < op_prio (node
))
1249 pp_right_paren (buffer
);
1250 pp_string (buffer
, str
);
1251 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1252 op0
= component_ref_field_offset (node
);
1253 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1255 pp_string (buffer
, "{off: ");
1256 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1257 pp_right_brace (buffer
);
1262 pp_string (buffer
, "BIT_FIELD_REF <");
1263 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1264 pp_string (buffer
, ", ");
1265 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1266 pp_string (buffer
, ", ");
1267 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1268 pp_greater (buffer
);
1272 case ARRAY_RANGE_REF
:
1273 op0
= TREE_OPERAND (node
, 0);
1274 if (op_prio (op0
) < op_prio (node
))
1275 pp_left_paren (buffer
);
1276 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1277 if (op_prio (op0
) < op_prio (node
))
1278 pp_right_paren (buffer
);
1279 pp_left_bracket (buffer
);
1280 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1281 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1282 pp_string (buffer
, " ...");
1283 pp_right_bracket (buffer
);
1285 op0
= array_ref_low_bound (node
);
1286 op1
= array_ref_element_size (node
);
1288 if (!integer_zerop (op0
)
1289 || TREE_OPERAND (node
, 2)
1290 || TREE_OPERAND (node
, 3))
1292 pp_string (buffer
, "{lb: ");
1293 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1294 pp_string (buffer
, " sz: ");
1295 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1296 pp_right_brace (buffer
);
1302 unsigned HOST_WIDE_INT ix
;
1304 bool is_struct_init
= false;
1305 bool is_array_init
= false;
1306 double_int curidx
= double_int_zero
;
1307 pp_left_brace (buffer
);
1308 if (TREE_CLOBBER_P (node
))
1309 pp_string (buffer
, "CLOBBER");
1310 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1311 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1312 is_struct_init
= true;
1313 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
1314 && TYPE_DOMAIN (TREE_TYPE (node
))
1315 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
1316 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
1319 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
1320 is_array_init
= true;
1321 curidx
= tree_to_double_int (minv
);
1323 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1330 dump_generic_node (buffer
, field
, spc
, flags
, false);
1333 else if (is_array_init
1334 && (TREE_CODE (field
) != INTEGER_CST
1335 || tree_to_double_int (field
) != curidx
))
1337 pp_left_bracket (buffer
);
1338 if (TREE_CODE (field
) == RANGE_EXPR
)
1340 dump_generic_node (buffer
, TREE_OPERAND (field
, 0), spc
,
1342 pp_string (buffer
, " ... ");
1343 dump_generic_node (buffer
, TREE_OPERAND (field
, 1), spc
,
1345 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
1346 curidx
= tree_to_double_int (TREE_OPERAND (field
, 1));
1349 dump_generic_node (buffer
, field
, spc
, flags
, false);
1350 if (TREE_CODE (field
) == INTEGER_CST
)
1351 curidx
= tree_to_double_int (field
);
1352 pp_string (buffer
, "]=");
1356 curidx
+= double_int_one
;
1357 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1358 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1359 val
= TREE_OPERAND (val
, 0);
1360 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1361 dump_decl_name (buffer
, val
, flags
);
1363 dump_generic_node (buffer
, val
, spc
, flags
, false);
1364 if (ix
!= vec_safe_length (CONSTRUCTOR_ELTS (node
)) - 1)
1370 pp_right_brace (buffer
);
1377 if (flags
& TDF_SLIM
)
1379 pp_string (buffer
, "<COMPOUND_EXPR>");
1383 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1384 spc
, flags
, !(flags
& TDF_SLIM
));
1385 if (flags
& TDF_SLIM
)
1386 newline_and_indent (buffer
, spc
);
1393 for (tp
= &TREE_OPERAND (node
, 1);
1394 TREE_CODE (*tp
) == COMPOUND_EXPR
;
1395 tp
= &TREE_OPERAND (*tp
, 1))
1397 dump_generic_node (buffer
, TREE_OPERAND (*tp
, 0),
1398 spc
, flags
, !(flags
& TDF_SLIM
));
1399 if (flags
& TDF_SLIM
)
1400 newline_and_indent (buffer
, spc
);
1408 dump_generic_node (buffer
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
1412 case STATEMENT_LIST
:
1414 tree_stmt_iterator si
;
1417 if (flags
& TDF_SLIM
)
1419 pp_string (buffer
, "<STATEMENT_LIST>");
1423 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
1426 newline_and_indent (buffer
, spc
);
1429 dump_generic_node (buffer
, tsi_stmt (si
), spc
, flags
, true);
1436 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
,
1441 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
,
1446 pp_string (buffer
, "TARGET_EXPR <");
1447 dump_generic_node (buffer
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
1450 dump_generic_node (buffer
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
1451 pp_greater (buffer
);
1455 print_declaration (buffer
, DECL_EXPR_DECL (node
), spc
, flags
);
1460 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
1462 pp_string (buffer
, "if (");
1463 dump_generic_node (buffer
, COND_EXPR_COND (node
), spc
, flags
, false);
1464 pp_right_paren (buffer
);
1465 /* The lowered cond_exprs should always be printed in full. */
1466 if (COND_EXPR_THEN (node
)
1467 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
1468 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
1469 && COND_EXPR_ELSE (node
)
1470 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
1471 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
1474 dump_generic_node (buffer
, COND_EXPR_THEN (node
),
1476 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1478 pp_string (buffer
, " else ");
1479 dump_generic_node (buffer
, COND_EXPR_ELSE (node
),
1483 else if (!(flags
& TDF_SLIM
))
1485 /* Output COND_EXPR_THEN. */
1486 if (COND_EXPR_THEN (node
))
1488 newline_and_indent (buffer
, spc
+2);
1489 pp_left_brace (buffer
);
1490 newline_and_indent (buffer
, spc
+4);
1491 dump_generic_node (buffer
, COND_EXPR_THEN (node
), spc
+4,
1493 newline_and_indent (buffer
, spc
+2);
1494 pp_right_brace (buffer
);
1497 /* Output COND_EXPR_ELSE. */
1498 if (COND_EXPR_ELSE (node
)
1499 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1501 newline_and_indent (buffer
, spc
);
1502 pp_string (buffer
, "else");
1503 newline_and_indent (buffer
, spc
+2);
1504 pp_left_brace (buffer
);
1505 newline_and_indent (buffer
, spc
+4);
1506 dump_generic_node (buffer
, COND_EXPR_ELSE (node
), spc
+4,
1508 newline_and_indent (buffer
, spc
+2);
1509 pp_right_brace (buffer
);
1516 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1518 pp_question (buffer
);
1520 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1524 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1529 pp_left_brace (buffer
);
1530 if (!(flags
& TDF_SLIM
))
1532 if (BIND_EXPR_VARS (node
))
1534 pp_newline (buffer
);
1536 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
1538 print_declaration (buffer
, op0
, spc
+2, flags
);
1539 pp_newline (buffer
);
1543 newline_and_indent (buffer
, spc
+2);
1544 dump_generic_node (buffer
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
1545 newline_and_indent (buffer
, spc
);
1546 pp_right_brace (buffer
);
1552 print_call_name (buffer
, CALL_EXPR_FN (node
), flags
);
1554 /* Print parameters. */
1556 pp_left_paren (buffer
);
1559 call_expr_arg_iterator iter
;
1560 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
1562 dump_generic_node (buffer
, arg
, spc
, flags
, false);
1563 if (more_call_expr_args_p (&iter
))
1570 if (CALL_EXPR_VA_ARG_PACK (node
))
1572 if (call_expr_nargs (node
) > 0)
1577 pp_string (buffer
, "__builtin_va_arg_pack ()");
1579 pp_right_paren (buffer
);
1581 op1
= CALL_EXPR_STATIC_CHAIN (node
);
1584 pp_string (buffer
, " [static-chain: ");
1585 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1586 pp_right_bracket (buffer
);
1589 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
1590 pp_string (buffer
, " [return slot optimization]");
1591 if (CALL_EXPR_TAILCALL (node
))
1592 pp_string (buffer
, " [tail call]");
1595 case WITH_CLEANUP_EXPR
:
1599 case CLEANUP_POINT_EXPR
:
1600 pp_string (buffer
, "<<cleanup_point ");
1601 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1602 pp_string (buffer
, ">>");
1605 case PLACEHOLDER_EXPR
:
1606 pp_string (buffer
, "<PLACEHOLDER_EXPR ");
1607 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1608 pp_greater (buffer
);
1611 /* Binary arithmetic and logic expressions. */
1612 case WIDEN_SUM_EXPR
:
1613 case WIDEN_MULT_EXPR
:
1615 case MULT_HIGHPART_EXPR
:
1617 case POINTER_PLUS_EXPR
:
1619 case TRUNC_DIV_EXPR
:
1621 case FLOOR_DIV_EXPR
:
1622 case ROUND_DIV_EXPR
:
1623 case TRUNC_MOD_EXPR
:
1625 case FLOOR_MOD_EXPR
:
1626 case ROUND_MOD_EXPR
:
1628 case EXACT_DIV_EXPR
:
1633 case VEC_LSHIFT_EXPR
:
1634 case VEC_RSHIFT_EXPR
:
1635 case WIDEN_LSHIFT_EXPR
:
1639 case TRUTH_ANDIF_EXPR
:
1640 case TRUTH_ORIF_EXPR
:
1641 case TRUTH_AND_EXPR
:
1643 case TRUTH_XOR_EXPR
:
1657 case UNORDERED_EXPR
:
1659 const char *op
= op_symbol (node
);
1660 op0
= TREE_OPERAND (node
, 0);
1661 op1
= TREE_OPERAND (node
, 1);
1663 /* When the operands are expressions with less priority,
1664 keep semantics of the tree representation. */
1665 if (op_prio (op0
) <= op_prio (node
))
1667 pp_left_paren (buffer
);
1668 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1669 pp_right_paren (buffer
);
1672 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1675 pp_string (buffer
, op
);
1678 /* When the operands are expressions with less priority,
1679 keep semantics of the tree representation. */
1680 if (op_prio (op1
) <= op_prio (node
))
1682 pp_left_paren (buffer
);
1683 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1684 pp_right_paren (buffer
);
1687 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1691 /* Unary arithmetic and logic expressions. */
1694 case TRUTH_NOT_EXPR
:
1696 case PREDECREMENT_EXPR
:
1697 case PREINCREMENT_EXPR
:
1699 if (TREE_CODE (node
) == ADDR_EXPR
1700 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
1701 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
1702 ; /* Do not output '&' for strings and function pointers. */
1704 pp_string (buffer
, op_symbol (node
));
1706 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1708 pp_left_paren (buffer
);
1709 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1710 pp_right_paren (buffer
);
1713 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1716 case POSTDECREMENT_EXPR
:
1717 case POSTINCREMENT_EXPR
:
1718 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1720 pp_left_paren (buffer
);
1721 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1722 pp_right_paren (buffer
);
1725 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1726 pp_string (buffer
, op_symbol (node
));
1730 pp_string (buffer
, "MIN_EXPR <");
1731 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1732 pp_string (buffer
, ", ");
1733 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1734 pp_greater (buffer
);
1738 pp_string (buffer
, "MAX_EXPR <");
1739 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1740 pp_string (buffer
, ", ");
1741 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1742 pp_greater (buffer
);
1746 pp_string (buffer
, "ABS_EXPR <");
1747 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1748 pp_greater (buffer
);
1755 case ADDR_SPACE_CONVERT_EXPR
:
1756 case FIXED_CONVERT_EXPR
:
1757 case FIX_TRUNC_EXPR
:
1760 type
= TREE_TYPE (node
);
1761 op0
= TREE_OPERAND (node
, 0);
1762 if (type
!= TREE_TYPE (op0
))
1764 pp_left_paren (buffer
);
1765 dump_generic_node (buffer
, type
, spc
, flags
, false);
1766 pp_string (buffer
, ") ");
1768 if (op_prio (op0
) < op_prio (node
))
1769 pp_left_paren (buffer
);
1770 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1771 if (op_prio (op0
) < op_prio (node
))
1772 pp_right_paren (buffer
);
1775 case VIEW_CONVERT_EXPR
:
1776 pp_string (buffer
, "VIEW_CONVERT_EXPR<");
1777 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1778 pp_string (buffer
, ">(");
1779 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1780 pp_right_paren (buffer
);
1784 pp_string (buffer
, "((");
1785 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1786 pp_string (buffer
, "))");
1789 case NON_LVALUE_EXPR
:
1790 pp_string (buffer
, "NON_LVALUE_EXPR <");
1791 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1792 pp_greater (buffer
);
1796 pp_string (buffer
, "SAVE_EXPR <");
1797 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1798 pp_greater (buffer
);
1802 pp_string (buffer
, "COMPLEX_EXPR <");
1803 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1804 pp_string (buffer
, ", ");
1805 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1806 pp_greater (buffer
);
1810 pp_string (buffer
, "CONJ_EXPR <");
1811 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1812 pp_greater (buffer
);
1816 pp_string (buffer
, "REALPART_EXPR <");
1817 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1818 pp_greater (buffer
);
1822 pp_string (buffer
, "IMAGPART_EXPR <");
1823 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1824 pp_greater (buffer
);
1828 pp_string (buffer
, "VA_ARG_EXPR <");
1829 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1830 pp_greater (buffer
);
1833 case TRY_FINALLY_EXPR
:
1834 case TRY_CATCH_EXPR
:
1835 pp_string (buffer
, "try");
1836 newline_and_indent (buffer
, spc
+2);
1837 pp_left_brace (buffer
);
1838 newline_and_indent (buffer
, spc
+4);
1839 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
1840 newline_and_indent (buffer
, spc
+2);
1841 pp_right_brace (buffer
);
1842 newline_and_indent (buffer
, spc
);
1844 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
1845 newline_and_indent (buffer
, spc
+2);
1846 pp_left_brace (buffer
);
1847 newline_and_indent (buffer
, spc
+4);
1848 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
1849 newline_and_indent (buffer
, spc
+2);
1850 pp_right_brace (buffer
);
1855 pp_string (buffer
, "catch (");
1856 dump_generic_node (buffer
, CATCH_TYPES (node
), spc
+2, flags
, false);
1857 pp_right_paren (buffer
);
1858 newline_and_indent (buffer
, spc
+2);
1859 pp_left_brace (buffer
);
1860 newline_and_indent (buffer
, spc
+4);
1861 dump_generic_node (buffer
, CATCH_BODY (node
), spc
+4, flags
, true);
1862 newline_and_indent (buffer
, spc
+2);
1863 pp_right_brace (buffer
);
1867 case EH_FILTER_EXPR
:
1868 pp_string (buffer
, "<<<eh_filter (");
1869 dump_generic_node (buffer
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
1870 pp_string (buffer
, ")>>>");
1871 newline_and_indent (buffer
, spc
+2);
1872 pp_left_brace (buffer
);
1873 newline_and_indent (buffer
, spc
+4);
1874 dump_generic_node (buffer
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
1875 newline_and_indent (buffer
, spc
+2);
1876 pp_right_brace (buffer
);
1881 op0
= TREE_OPERAND (node
, 0);
1882 /* If this is for break or continue, don't bother printing it. */
1883 if (DECL_NAME (op0
))
1885 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
1886 if (strcmp (name
, "break") == 0
1887 || strcmp (name
, "continue") == 0)
1890 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1892 if (DECL_NONLOCAL (op0
))
1893 pp_string (buffer
, " [non-local]");
1897 pp_string (buffer
, "while (1)");
1898 if (!(flags
& TDF_SLIM
))
1900 newline_and_indent (buffer
, spc
+2);
1901 pp_left_brace (buffer
);
1902 newline_and_indent (buffer
, spc
+4);
1903 dump_generic_node (buffer
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
1904 newline_and_indent (buffer
, spc
+2);
1905 pp_right_brace (buffer
);
1911 pp_string (buffer
, "// predicted ");
1912 if (PREDICT_EXPR_OUTCOME (node
))
1913 pp_string (buffer
, "likely by ");
1915 pp_string (buffer
, "unlikely by ");
1916 pp_string (buffer
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
1917 pp_string (buffer
, " predictor.");
1921 pp_string (buffer
, "return");
1922 op0
= TREE_OPERAND (node
, 0);
1926 if (TREE_CODE (op0
) == MODIFY_EXPR
)
1927 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1),
1930 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1935 pp_string (buffer
, "if (");
1936 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1937 pp_string (buffer
, ") break");
1941 pp_string (buffer
, "switch (");
1942 dump_generic_node (buffer
, SWITCH_COND (node
), spc
, flags
, false);
1943 pp_right_paren (buffer
);
1944 if (!(flags
& TDF_SLIM
))
1946 newline_and_indent (buffer
, spc
+2);
1947 pp_left_brace (buffer
);
1948 if (SWITCH_BODY (node
))
1950 newline_and_indent (buffer
, spc
+4);
1951 dump_generic_node (buffer
, SWITCH_BODY (node
), spc
+4, flags
,
1956 tree vec
= SWITCH_LABELS (node
);
1957 size_t i
, n
= TREE_VEC_LENGTH (vec
);
1958 for (i
= 0; i
< n
; ++i
)
1960 tree elt
= TREE_VEC_ELT (vec
, i
);
1961 newline_and_indent (buffer
, spc
+4);
1964 dump_generic_node (buffer
, elt
, spc
+4, flags
, false);
1965 pp_string (buffer
, " goto ");
1966 dump_generic_node (buffer
, CASE_LABEL (elt
), spc
+4,
1968 pp_semicolon (buffer
);
1971 pp_string (buffer
, "case ???: goto ???;");
1974 newline_and_indent (buffer
, spc
+2);
1975 pp_right_brace (buffer
);
1981 op0
= GOTO_DESTINATION (node
);
1982 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
1984 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
1985 if (strcmp (name
, "break") == 0
1986 || strcmp (name
, "continue") == 0)
1988 pp_string (buffer
, name
);
1992 pp_string (buffer
, "goto ");
1993 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1997 pp_string (buffer
, "__asm__");
1998 if (ASM_VOLATILE_P (node
))
1999 pp_string (buffer
, " __volatile__");
2000 pp_left_paren (buffer
);
2001 dump_generic_node (buffer
, ASM_STRING (node
), spc
, flags
, false);
2003 dump_generic_node (buffer
, ASM_OUTPUTS (node
), spc
, flags
, false);
2005 dump_generic_node (buffer
, ASM_INPUTS (node
), spc
, flags
, false);
2006 if (ASM_CLOBBERS (node
))
2009 dump_generic_node (buffer
, ASM_CLOBBERS (node
), spc
, flags
, false);
2011 pp_right_paren (buffer
);
2014 case CASE_LABEL_EXPR
:
2015 if (CASE_LOW (node
) && CASE_HIGH (node
))
2017 pp_string (buffer
, "case ");
2018 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
2019 pp_string (buffer
, " ... ");
2020 dump_generic_node (buffer
, CASE_HIGH (node
), spc
, flags
, false);
2022 else if (CASE_LOW (node
))
2024 pp_string (buffer
, "case ");
2025 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
2028 pp_string (buffer
, "default");
2033 pp_string (buffer
, "OBJ_TYPE_REF(");
2034 dump_generic_node (buffer
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2035 pp_semicolon (buffer
);
2036 dump_generic_node (buffer
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2038 dump_generic_node (buffer
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2039 pp_right_paren (buffer
);
2043 if (SSA_NAME_IDENTIFIER (node
))
2044 dump_generic_node (buffer
, SSA_NAME_IDENTIFIER (node
),
2046 pp_underscore (buffer
);
2047 pp_decimal_int (buffer
, SSA_NAME_VERSION (node
));
2048 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2049 pp_string (buffer
, "(ab)");
2050 else if (SSA_NAME_IS_DEFAULT_DEF (node
))
2051 pp_string (buffer
, "(D)");
2054 case WITH_SIZE_EXPR
:
2055 pp_string (buffer
, "WITH_SIZE_EXPR <");
2056 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2057 pp_string (buffer
, ", ");
2058 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2059 pp_greater (buffer
);
2063 pp_string (buffer
, "ASSERT_EXPR <");
2064 dump_generic_node (buffer
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2065 pp_string (buffer
, ", ");
2066 dump_generic_node (buffer
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2067 pp_greater (buffer
);
2071 pp_string (buffer
, "scev_known");
2074 case SCEV_NOT_KNOWN
:
2075 pp_string (buffer
, "scev_not_known");
2078 case POLYNOMIAL_CHREC
:
2079 pp_left_brace (buffer
);
2080 dump_generic_node (buffer
, CHREC_LEFT (node
), spc
, flags
, false);
2081 pp_string (buffer
, ", +, ");
2082 dump_generic_node (buffer
, CHREC_RIGHT (node
), spc
, flags
, false);
2083 pp_string (buffer
, "}_");
2084 dump_generic_node (buffer
, CHREC_VAR (node
), spc
, flags
, false);
2088 case REALIGN_LOAD_EXPR
:
2089 pp_string (buffer
, "REALIGN_LOAD <");
2090 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2091 pp_string (buffer
, ", ");
2092 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2093 pp_string (buffer
, ", ");
2094 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2095 pp_greater (buffer
);
2099 pp_string (buffer
, " VEC_COND_EXPR < ");
2100 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2101 pp_string (buffer
, " , ");
2102 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2103 pp_string (buffer
, " , ");
2104 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2105 pp_string (buffer
, " > ");
2109 pp_string (buffer
, " VEC_PERM_EXPR < ");
2110 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2111 pp_string (buffer
, " , ");
2112 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2113 pp_string (buffer
, " , ");
2114 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2115 pp_string (buffer
, " > ");
2119 pp_string (buffer
, " DOT_PROD_EXPR < ");
2120 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2121 pp_string (buffer
, ", ");
2122 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2123 pp_string (buffer
, ", ");
2124 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2125 pp_string (buffer
, " > ");
2128 case WIDEN_MULT_PLUS_EXPR
:
2129 pp_string (buffer
, " WIDEN_MULT_PLUS_EXPR < ");
2130 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2131 pp_string (buffer
, ", ");
2132 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2133 pp_string (buffer
, ", ");
2134 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2135 pp_string (buffer
, " > ");
2138 case WIDEN_MULT_MINUS_EXPR
:
2139 pp_string (buffer
, " WIDEN_MULT_MINUS_EXPR < ");
2140 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2141 pp_string (buffer
, ", ");
2142 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2143 pp_string (buffer
, ", ");
2144 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2145 pp_string (buffer
, " > ");
2149 pp_string (buffer
, " FMA_EXPR < ");
2150 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2151 pp_string (buffer
, ", ");
2152 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2153 pp_string (buffer
, ", ");
2154 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2155 pp_string (buffer
, " > ");
2159 pp_string (buffer
, "#pragma omp parallel");
2160 dump_omp_clauses (buffer
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2163 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2165 newline_and_indent (buffer
, spc
+ 2);
2166 pp_left_brace (buffer
);
2167 newline_and_indent (buffer
, spc
+ 4);
2168 dump_generic_node (buffer
, OMP_BODY (node
), spc
+ 4, flags
, false);
2169 newline_and_indent (buffer
, spc
+ 2);
2170 pp_right_brace (buffer
);
2176 pp_string (buffer
, "#pragma omp task");
2177 dump_omp_clauses (buffer
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2181 pp_string (buffer
, "#pragma omp for");
2182 dump_omp_clauses (buffer
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2184 if (!(flags
& TDF_SLIM
))
2188 if (OMP_FOR_PRE_BODY (node
))
2190 newline_and_indent (buffer
, spc
+ 2);
2191 pp_left_brace (buffer
);
2193 newline_and_indent (buffer
, spc
);
2194 dump_generic_node (buffer
, OMP_FOR_PRE_BODY (node
),
2198 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
2201 newline_and_indent (buffer
, spc
);
2202 pp_string (buffer
, "for (");
2203 dump_generic_node (buffer
, TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
2205 pp_string (buffer
, "; ");
2206 dump_generic_node (buffer
, TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
2208 pp_string (buffer
, "; ");
2209 dump_generic_node (buffer
, TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
2211 pp_right_paren (buffer
);
2213 if (OMP_FOR_BODY (node
))
2215 newline_and_indent (buffer
, spc
+ 2);
2216 pp_left_brace (buffer
);
2217 newline_and_indent (buffer
, spc
+ 4);
2218 dump_generic_node (buffer
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
2220 newline_and_indent (buffer
, spc
+ 2);
2221 pp_right_brace (buffer
);
2223 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
2224 if (OMP_FOR_PRE_BODY (node
))
2227 newline_and_indent (buffer
, spc
+ 2);
2228 pp_right_brace (buffer
);
2235 pp_string (buffer
, "#pragma omp sections");
2236 dump_omp_clauses (buffer
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
2240 pp_string (buffer
, "#pragma omp section");
2244 pp_string (buffer
, "#pragma omp master");
2248 pp_string (buffer
, "#pragma omp ordered");
2252 pp_string (buffer
, "#pragma omp critical");
2253 if (OMP_CRITICAL_NAME (node
))
2256 pp_left_paren (buffer
);
2257 dump_generic_node (buffer
, OMP_CRITICAL_NAME (node
), spc
,
2259 pp_right_paren (buffer
);
2264 pp_string (buffer
, "#pragma omp atomic");
2265 newline_and_indent (buffer
, spc
+ 2);
2266 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2270 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2273 case OMP_ATOMIC_READ
:
2274 pp_string (buffer
, "#pragma omp atomic read");
2275 newline_and_indent (buffer
, spc
+ 2);
2276 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2280 case OMP_ATOMIC_CAPTURE_OLD
:
2281 case OMP_ATOMIC_CAPTURE_NEW
:
2282 pp_string (buffer
, "#pragma omp atomic capture");
2283 newline_and_indent (buffer
, spc
+ 2);
2284 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2288 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2292 pp_string (buffer
, "#pragma omp single");
2293 dump_omp_clauses (buffer
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
2297 dump_omp_clause (buffer
, node
, spc
, flags
);
2301 case TRANSACTION_EXPR
:
2302 if (TRANSACTION_EXPR_OUTER (node
))
2303 pp_string (buffer
, "__transaction_atomic [[outer]]");
2304 else if (TRANSACTION_EXPR_RELAXED (node
))
2305 pp_string (buffer
, "__transaction_relaxed");
2307 pp_string (buffer
, "__transaction_atomic");
2308 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
2310 newline_and_indent (buffer
, spc
);
2311 pp_left_brace (buffer
);
2312 newline_and_indent (buffer
, spc
+ 2);
2313 dump_generic_node (buffer
, TRANSACTION_EXPR_BODY (node
),
2314 spc
+ 2, flags
, false);
2315 newline_and_indent (buffer
, spc
);
2316 pp_right_brace (buffer
);
2321 case REDUC_MAX_EXPR
:
2322 pp_string (buffer
, " REDUC_MAX_EXPR < ");
2323 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2324 pp_string (buffer
, " > ");
2327 case REDUC_MIN_EXPR
:
2328 pp_string (buffer
, " REDUC_MIN_EXPR < ");
2329 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2330 pp_string (buffer
, " > ");
2333 case REDUC_PLUS_EXPR
:
2334 pp_string (buffer
, " REDUC_PLUS_EXPR < ");
2335 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2336 pp_string (buffer
, " > ");
2339 case VEC_WIDEN_MULT_HI_EXPR
:
2340 case VEC_WIDEN_MULT_LO_EXPR
:
2341 case VEC_WIDEN_MULT_EVEN_EXPR
:
2342 case VEC_WIDEN_MULT_ODD_EXPR
:
2343 case VEC_WIDEN_LSHIFT_HI_EXPR
:
2344 case VEC_WIDEN_LSHIFT_LO_EXPR
:
2346 for (str
= tree_code_name
[code
]; *str
; str
++)
2347 pp_character (buffer
, TOUPPER (*str
));
2348 pp_string (buffer
, " < ");
2349 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2350 pp_string (buffer
, ", ");
2351 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2352 pp_string (buffer
, " > ");
2355 case VEC_UNPACK_HI_EXPR
:
2356 pp_string (buffer
, " VEC_UNPACK_HI_EXPR < ");
2357 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2358 pp_string (buffer
, " > ");
2361 case VEC_UNPACK_LO_EXPR
:
2362 pp_string (buffer
, " VEC_UNPACK_LO_EXPR < ");
2363 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2364 pp_string (buffer
, " > ");
2367 case VEC_UNPACK_FLOAT_HI_EXPR
:
2368 pp_string (buffer
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2369 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2370 pp_string (buffer
, " > ");
2373 case VEC_UNPACK_FLOAT_LO_EXPR
:
2374 pp_string (buffer
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2375 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2376 pp_string (buffer
, " > ");
2379 case VEC_PACK_TRUNC_EXPR
:
2380 pp_string (buffer
, " VEC_PACK_TRUNC_EXPR < ");
2381 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2382 pp_string (buffer
, ", ");
2383 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2384 pp_string (buffer
, " > ");
2387 case VEC_PACK_SAT_EXPR
:
2388 pp_string (buffer
, " VEC_PACK_SAT_EXPR < ");
2389 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2390 pp_string (buffer
, ", ");
2391 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2392 pp_string (buffer
, " > ");
2395 case VEC_PACK_FIX_TRUNC_EXPR
:
2396 pp_string (buffer
, " VEC_PACK_FIX_TRUNC_EXPR < ");
2397 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2398 pp_string (buffer
, ", ");
2399 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2400 pp_string (buffer
, " > ");
2404 dump_block_node (buffer
, node
, spc
, flags
);
2411 if (is_stmt
&& is_expr
)
2412 pp_semicolon (buffer
);
2417 /* Print the declaration of a variable. */
2420 print_declaration (pretty_printer
*buffer
, tree t
, int spc
, int flags
)
2424 if (TREE_CODE (t
) == TYPE_DECL
)
2425 pp_string (buffer
, "typedef ");
2427 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
2428 pp_string (buffer
, "register ");
2430 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
2431 pp_string (buffer
, "extern ");
2432 else if (TREE_STATIC (t
))
2433 pp_string (buffer
, "static ");
2435 /* Print the type and name. */
2436 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
2440 /* Print array's type. */
2441 tmp
= TREE_TYPE (t
);
2442 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
2443 tmp
= TREE_TYPE (tmp
);
2444 dump_generic_node (buffer
, TREE_TYPE (tmp
), spc
, flags
, false);
2446 /* Print variable's name. */
2448 dump_generic_node (buffer
, t
, spc
, flags
, false);
2450 /* Print the dimensions. */
2451 tmp
= TREE_TYPE (t
);
2452 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
2454 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
2455 tmp
= TREE_TYPE (tmp
);
2458 else if (TREE_CODE (t
) == FUNCTION_DECL
)
2460 dump_generic_node (buffer
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
2462 dump_decl_name (buffer
, t
, flags
);
2463 dump_function_declaration (buffer
, TREE_TYPE (t
), spc
, flags
);
2467 /* Print type declaration. */
2468 dump_generic_node (buffer
, TREE_TYPE (t
), spc
, flags
, false);
2470 /* Print variable's name. */
2472 dump_generic_node (buffer
, t
, spc
, flags
, false);
2475 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
2477 pp_string (buffer
, " __asm__ ");
2478 pp_left_paren (buffer
);
2479 dump_generic_node (buffer
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
2480 pp_right_paren (buffer
);
2483 /* The initial value of a function serves to determine whether the function
2484 is declared or defined. So the following does not apply to function
2486 if (TREE_CODE (t
) != FUNCTION_DECL
)
2488 /* Print the initial value. */
2489 if (DECL_INITIAL (t
))
2494 dump_generic_node (buffer
, DECL_INITIAL (t
), spc
, flags
, false);
2498 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
2500 pp_string (buffer
, " [value-expr: ");
2501 dump_generic_node (buffer
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
2502 pp_right_bracket (buffer
);
2505 pp_semicolon (buffer
);
2509 /* Prints a structure: name, fields, and methods.
2510 FIXME: Still incomplete. */
2513 print_struct_decl (pretty_printer
*buffer
, const_tree node
, int spc
, int flags
)
2515 /* Print the name of the structure. */
2516 if (TYPE_NAME (node
))
2519 if (TREE_CODE (node
) == RECORD_TYPE
)
2520 pp_string (buffer
, "struct ");
2521 else if ((TREE_CODE (node
) == UNION_TYPE
2522 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
2523 pp_string (buffer
, "union ");
2525 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, 0, false);
2528 /* Print the contents of the structure. */
2529 pp_newline (buffer
);
2531 pp_left_brace (buffer
);
2532 pp_newline (buffer
);
2534 /* Print the fields of the structure. */
2537 tmp
= TYPE_FIELDS (node
);
2540 /* Avoid to print recursively the structure. */
2541 /* FIXME : Not implemented correctly...,
2542 what about the case when we have a cycle in the contain graph? ...
2543 Maybe this could be solved by looking at the scope in which the
2544 structure was declared. */
2545 if (TREE_TYPE (tmp
) != node
2546 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
2547 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
2549 print_declaration (buffer
, tmp
, spc
+2, flags
);
2550 pp_newline (buffer
);
2552 tmp
= DECL_CHAIN (tmp
);
2556 pp_right_brace (buffer
);
2559 /* Return the priority of the operator CODE.
2561 From lowest to highest precedence with either left-to-right (L-R)
2562 or right-to-left (R-L) associativity]:
2565 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2577 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2578 15 [L-R] fn() [] -> .
2580 unary +, - and * have higher precedence than the corresponding binary
2584 op_code_prio (enum tree_code code
)
2601 case TRUTH_ORIF_EXPR
:
2604 case TRUTH_AND_EXPR
:
2605 case TRUTH_ANDIF_EXPR
:
2612 case TRUTH_XOR_EXPR
:
2629 case UNORDERED_EXPR
:
2640 case VEC_WIDEN_LSHIFT_HI_EXPR
:
2641 case VEC_WIDEN_LSHIFT_LO_EXPR
:
2642 case WIDEN_LSHIFT_EXPR
:
2645 case WIDEN_SUM_EXPR
:
2647 case POINTER_PLUS_EXPR
:
2651 case VEC_WIDEN_MULT_HI_EXPR
:
2652 case VEC_WIDEN_MULT_LO_EXPR
:
2653 case WIDEN_MULT_EXPR
:
2655 case WIDEN_MULT_PLUS_EXPR
:
2656 case WIDEN_MULT_MINUS_EXPR
:
2658 case MULT_HIGHPART_EXPR
:
2659 case TRUNC_DIV_EXPR
:
2661 case FLOOR_DIV_EXPR
:
2662 case ROUND_DIV_EXPR
:
2664 case EXACT_DIV_EXPR
:
2665 case TRUNC_MOD_EXPR
:
2667 case FLOOR_MOD_EXPR
:
2668 case ROUND_MOD_EXPR
:
2672 case TRUTH_NOT_EXPR
:
2674 case POSTINCREMENT_EXPR
:
2675 case POSTDECREMENT_EXPR
:
2676 case PREINCREMENT_EXPR
:
2677 case PREDECREMENT_EXPR
:
2683 case FIX_TRUNC_EXPR
:
2689 case ARRAY_RANGE_REF
:
2693 /* Special expressions. */
2699 case REDUC_MAX_EXPR
:
2700 case REDUC_MIN_EXPR
:
2701 case REDUC_PLUS_EXPR
:
2702 case VEC_LSHIFT_EXPR
:
2703 case VEC_RSHIFT_EXPR
:
2704 case VEC_UNPACK_HI_EXPR
:
2705 case VEC_UNPACK_LO_EXPR
:
2706 case VEC_UNPACK_FLOAT_HI_EXPR
:
2707 case VEC_UNPACK_FLOAT_LO_EXPR
:
2708 case VEC_PACK_TRUNC_EXPR
:
2709 case VEC_PACK_SAT_EXPR
:
2713 /* Return an arbitrarily high precedence to avoid surrounding single
2714 VAR_DECLs in ()s. */
2719 /* Return the priority of the operator OP. */
2722 op_prio (const_tree op
)
2724 enum tree_code code
;
2729 code
= TREE_CODE (op
);
2730 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
2731 return op_prio (TREE_OPERAND (op
, 0));
2733 return op_code_prio (code
);
2736 /* Return the symbol associated with operator CODE. */
2739 op_symbol_code (enum tree_code code
)
2747 case TRUTH_ORIF_EXPR
:
2750 case TRUTH_AND_EXPR
:
2751 case TRUTH_ANDIF_EXPR
:
2757 case TRUTH_XOR_EXPR
:
2767 case UNORDERED_EXPR
:
2813 case VEC_LSHIFT_EXPR
:
2816 case VEC_RSHIFT_EXPR
:
2819 case WIDEN_LSHIFT_EXPR
:
2822 case POINTER_PLUS_EXPR
:
2828 case REDUC_PLUS_EXPR
:
2831 case WIDEN_SUM_EXPR
:
2834 case WIDEN_MULT_EXPR
:
2837 case MULT_HIGHPART_EXPR
:
2847 case TRUTH_NOT_EXPR
:
2854 case TRUNC_DIV_EXPR
:
2861 case FLOOR_DIV_EXPR
:
2864 case ROUND_DIV_EXPR
:
2867 case EXACT_DIV_EXPR
:
2870 case TRUNC_MOD_EXPR
:
2876 case FLOOR_MOD_EXPR
:
2879 case ROUND_MOD_EXPR
:
2882 case PREDECREMENT_EXPR
:
2885 case PREINCREMENT_EXPR
:
2888 case POSTDECREMENT_EXPR
:
2891 case POSTINCREMENT_EXPR
:
2901 return "<<< ??? >>>";
2905 /* Return the symbol associated with operator OP. */
2908 op_symbol (const_tree op
)
2910 return op_symbol_code (TREE_CODE (op
));
2913 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
2914 the gimple_call_fn of a GIMPLE_CALL. */
2917 print_call_name (pretty_printer
*buffer
, tree node
, int flags
)
2921 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
2922 op0
= TREE_OPERAND (op0
, 0);
2925 switch (TREE_CODE (op0
))
2930 dump_function_name (buffer
, op0
, flags
);
2936 op0
= TREE_OPERAND (op0
, 0);
2940 pp_left_paren (buffer
);
2941 dump_generic_node (buffer
, TREE_OPERAND (op0
, 0), 0, flags
, false);
2942 pp_string (buffer
, ") ? ");
2943 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1), 0, flags
, false);
2944 pp_string (buffer
, " : ");
2945 dump_generic_node (buffer
, TREE_OPERAND (op0
, 2), 0, flags
, false);
2949 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
2950 dump_function_name (buffer
, TREE_OPERAND (op0
, 0), flags
);
2952 dump_generic_node (buffer
, op0
, 0, flags
, false);
2956 if (integer_zerop (TREE_OPERAND (op0
, 1)))
2958 op0
= TREE_OPERAND (op0
, 0);
2965 dump_generic_node (buffer
, op0
, 0, flags
, false);
2973 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2976 pretty_print_string (pretty_printer
*buffer
, const char *str
)
2986 pp_string (buffer
, "\\b");
2990 pp_string (buffer
, "\\f");
2994 pp_string (buffer
, "\\n");
2998 pp_string (buffer
, "\\r");
3002 pp_string (buffer
, "\\t");
3006 pp_string (buffer
, "\\v");
3010 pp_string (buffer
, "\\\\");
3014 pp_string (buffer
, "\\\"");
3018 pp_string (buffer
, "\\'");
3021 /* No need to handle \0; the loop terminates on \0. */
3024 pp_string (buffer
, "\\1");
3028 pp_string (buffer
, "\\2");
3032 pp_string (buffer
, "\\3");
3036 pp_string (buffer
, "\\4");
3040 pp_string (buffer
, "\\5");
3044 pp_string (buffer
, "\\6");
3048 pp_string (buffer
, "\\7");
3052 pp_character (buffer
, str
[0]);
3060 maybe_init_pretty_print (FILE *file
)
3064 new (&buffer
) pretty_printer ();
3065 pp_needs_newline (&buffer
) = true;
3066 pp_translate_identifiers (&buffer
) = false;
3070 buffer
.buffer
->stream
= file
;
3074 newline_and_indent (pretty_printer
*buffer
, int spc
)
3076 pp_newline (buffer
);
3080 /* Handle a %K format for TEXT. Separate from default_tree_printer so
3081 it can also be used in front ends.
3082 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3086 percent_K_format (text_info
*text
)
3088 tree t
= va_arg (*text
->args_ptr
, tree
), block
;
3089 gcc_assert (text
->locus
!= NULL
);
3090 *text
->locus
= EXPR_LOCATION (t
);
3091 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3092 block
= TREE_BLOCK (t
);
3093 *pp_ti_abstract_origin (text
) = NULL
;
3095 && TREE_CODE (block
) == BLOCK
3096 && BLOCK_ABSTRACT_ORIGIN (block
))
3098 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3100 while (TREE_CODE (ao
) == BLOCK
3101 && BLOCK_ABSTRACT_ORIGIN (ao
)
3102 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3103 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3105 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3107 *pp_ti_abstract_origin (text
) = block
;
3110 block
= BLOCK_SUPERCONTEXT (block
);
3114 /* Print the identifier ID to PRETTY-PRINTER. */
3117 pp_tree_identifier (pretty_printer
*pp
, tree id
)
3119 if (pp_translate_identifiers (pp
))
3121 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
3122 pp_append_text (pp
, text
, text
+ strlen (text
));
3125 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
3126 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
3129 /* A helper function that is used to dump function information before the
3133 dump_function_header (FILE *dump_file
, tree fdecl
, int flags
)
3135 const char *dname
, *aname
;
3136 struct cgraph_node
*node
= cgraph_get_node (fdecl
);
3137 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
3139 dname
= lang_hooks
.decl_printable_name (fdecl
, 2);
3141 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
3142 aname
= (IDENTIFIER_POINTER
3143 (DECL_ASSEMBLER_NAME (fdecl
)));
3145 aname
= "<unset-asm-name>";
3147 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
3148 dname
, aname
, fun
->funcdef_no
);
3149 if (!(flags
& TDF_NOUID
))
3150 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
3153 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->symbol
.order
,
3154 node
->frequency
== NODE_FREQUENCY_HOT
3156 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
3157 ? " (unlikely executed)"
3158 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
3159 ? " (executed once)"
3163 fprintf (dump_file
, ")\n\n");