1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
3 2011 Free Software Foundation, Inc.
4 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
28 #include "tree-pretty-print.h"
30 #include "tree-flow.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
33 #include "tree-chrec.h"
34 #include "tree-pass.h"
35 #include "value-prof.h"
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 tree-pass.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);
140 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
141 to show in the dump. See TDF_* in tree-pass.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);
157 /* Print a single expression T on file FILE. FLAGS specifies details to show
158 in the dump. See TDF_* in tree-pass.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);
167 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
171 dump_decl_name (pretty_printer
*buffer
, tree node
, int flags
)
173 if (DECL_NAME (node
))
175 if ((flags
& TDF_ASMNAME
) && DECL_ASSEMBLER_NAME_SET_P (node
))
176 pp_tree_identifier (buffer
, DECL_ASSEMBLER_NAME (node
));
178 pp_tree_identifier (buffer
, DECL_NAME (node
));
180 if ((flags
& TDF_UID
) || DECL_NAME (node
) == NULL_TREE
)
182 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
183 pp_printf (buffer
, "L.%d", (int) LABEL_DECL_UID (node
));
184 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
186 if (flags
& TDF_NOUID
)
187 pp_string (buffer
, "D#xxxx");
189 pp_printf (buffer
, "D#%i", DEBUG_TEMP_UID (node
));
193 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
194 if (flags
& TDF_NOUID
)
195 pp_printf (buffer
, "%c.xxxx", c
);
197 pp_printf (buffer
, "%c.%u", c
, DECL_UID (node
));
200 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
202 if (flags
& TDF_NOUID
)
203 pp_printf (buffer
, "ptD.xxxx");
205 pp_printf (buffer
, "ptD.%u", DECL_PT_UID (node
));
209 /* Like the above, but used for pretty printing function calls. */
212 dump_function_name (pretty_printer
*buffer
, tree node
, int flags
)
214 if (TREE_CODE (node
) == NOP_EXPR
)
215 node
= TREE_OPERAND (node
, 0);
216 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
217 pp_string (buffer
, lang_hooks
.decl_printable_name (node
, 1));
219 dump_decl_name (buffer
, node
, flags
);
222 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
223 FLAGS are as in dump_generic_node. */
226 dump_function_declaration (pretty_printer
*buffer
, tree node
,
229 bool wrote_arg
= false;
233 pp_character (buffer
, '(');
235 /* Print the argument types. */
236 arg
= TYPE_ARG_TYPES (node
);
237 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
241 pp_character (buffer
, ',');
245 dump_generic_node (buffer
, TREE_VALUE (arg
), spc
, flags
, false);
246 arg
= TREE_CHAIN (arg
);
249 /* Drop the trailing void_type_node if we had any previous argument. */
250 if (arg
== void_list_node
&& !wrote_arg
)
251 pp_string (buffer
, "void");
252 /* Properly dump vararg function types. */
253 else if (!arg
&& wrote_arg
)
254 pp_string (buffer
, ", ...");
255 /* Avoid printing any arg for unprototyped functions. */
257 pp_character (buffer
, ')');
260 /* Dump the domain associated with an array. */
263 dump_array_domain (pretty_printer
*buffer
, tree domain
, int spc
, int flags
)
265 pp_character (buffer
, '[');
268 tree min
= TYPE_MIN_VALUE (domain
);
269 tree max
= TYPE_MAX_VALUE (domain
);
272 && integer_zerop (min
)
273 && host_integerp (max
, 0))
274 pp_wide_integer (buffer
, TREE_INT_CST_LOW (max
) + 1);
278 dump_generic_node (buffer
, min
, spc
, flags
, false);
279 pp_character (buffer
, ':');
281 dump_generic_node (buffer
, max
, spc
, flags
, false);
285 pp_string (buffer
, "<unknown>");
286 pp_character (buffer
, ']');
290 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
291 dump_generic_node. */
294 dump_omp_clause (pretty_printer
*buffer
, tree clause
, int spc
, int flags
)
298 switch (OMP_CLAUSE_CODE (clause
))
300 case OMP_CLAUSE_PRIVATE
:
303 case OMP_CLAUSE_SHARED
:
306 case OMP_CLAUSE_FIRSTPRIVATE
:
307 name
= "firstprivate";
309 case OMP_CLAUSE_LASTPRIVATE
:
310 name
= "lastprivate";
312 case OMP_CLAUSE_COPYIN
:
315 case OMP_CLAUSE_COPYPRIVATE
:
316 name
= "copyprivate";
319 pp_string (buffer
, name
);
320 pp_character (buffer
, '(');
321 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
323 pp_character (buffer
, ')');
326 case OMP_CLAUSE_REDUCTION
:
327 pp_string (buffer
, "reduction(");
328 pp_string (buffer
, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
329 pp_character (buffer
, ':');
330 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
332 pp_character (buffer
, ')');
336 pp_string (buffer
, "if(");
337 dump_generic_node (buffer
, OMP_CLAUSE_IF_EXPR (clause
),
339 pp_character (buffer
, ')');
342 case OMP_CLAUSE_NUM_THREADS
:
343 pp_string (buffer
, "num_threads(");
344 dump_generic_node (buffer
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
346 pp_character (buffer
, ')');
349 case OMP_CLAUSE_NOWAIT
:
350 pp_string (buffer
, "nowait");
352 case OMP_CLAUSE_ORDERED
:
353 pp_string (buffer
, "ordered");
356 case OMP_CLAUSE_DEFAULT
:
357 pp_string (buffer
, "default(");
358 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
360 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
362 case OMP_CLAUSE_DEFAULT_SHARED
:
363 pp_string (buffer
, "shared");
365 case OMP_CLAUSE_DEFAULT_NONE
:
366 pp_string (buffer
, "none");
368 case OMP_CLAUSE_DEFAULT_PRIVATE
:
369 pp_string (buffer
, "private");
371 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
372 pp_string (buffer
, "firstprivate");
377 pp_character (buffer
, ')');
380 case OMP_CLAUSE_SCHEDULE
:
381 pp_string (buffer
, "schedule(");
382 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
))
384 case OMP_CLAUSE_SCHEDULE_STATIC
:
385 pp_string (buffer
, "static");
387 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
388 pp_string (buffer
, "dynamic");
390 case OMP_CLAUSE_SCHEDULE_GUIDED
:
391 pp_string (buffer
, "guided");
393 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
394 pp_string (buffer
, "runtime");
396 case OMP_CLAUSE_SCHEDULE_AUTO
:
397 pp_string (buffer
, "auto");
402 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
404 pp_character (buffer
, ',');
405 dump_generic_node (buffer
,
406 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
409 pp_character (buffer
, ')');
412 case OMP_CLAUSE_UNTIED
:
413 pp_string (buffer
, "untied");
416 case OMP_CLAUSE_COLLAPSE
:
417 pp_string (buffer
, "collapse(");
418 dump_generic_node (buffer
,
419 OMP_CLAUSE_COLLAPSE_EXPR (clause
),
421 pp_character (buffer
, ')');
424 case OMP_CLAUSE_FINAL
:
425 pp_string (buffer
, "final(");
426 dump_generic_node (buffer
, OMP_CLAUSE_FINAL_EXPR (clause
),
428 pp_character (buffer
, ')');
431 case OMP_CLAUSE_MERGEABLE
:
432 pp_string (buffer
, "mergeable");
436 /* Should never happen. */
437 dump_generic_node (buffer
, clause
, spc
, flags
, false);
443 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
444 dump_generic_node. */
447 dump_omp_clauses (pretty_printer
*buffer
, tree clause
, int spc
, int flags
)
455 dump_omp_clause (buffer
, clause
, spc
, flags
);
456 clause
= OMP_CLAUSE_CHAIN (clause
);
464 /* Dump location LOC to BUFFER. */
467 dump_location (pretty_printer
*buffer
, location_t loc
)
469 expanded_location xloc
= expand_location (loc
);
471 pp_character (buffer
, '[');
474 pp_string (buffer
, xloc
.file
);
475 pp_string (buffer
, " : ");
477 pp_decimal_int (buffer
, xloc
.line
);
478 pp_string (buffer
, "] ");
482 /* Dump lexical block BLOCK. BUFFER, SPC and FLAGS are as in
483 dump_generic_node. */
486 dump_block_node (pretty_printer
*buffer
, tree block
, int spc
, int flags
)
490 pp_printf (buffer
, "BLOCK #%d ", BLOCK_NUMBER (block
));
492 if (flags
& TDF_ADDRESS
)
493 pp_printf (buffer
, "[%p] ", (void *) block
);
495 if (BLOCK_ABSTRACT (block
))
496 pp_string (buffer
, "[abstract] ");
498 if (TREE_ASM_WRITTEN (block
))
499 pp_string (buffer
, "[written] ");
501 if (flags
& TDF_SLIM
)
504 if (BLOCK_SOURCE_LOCATION (block
))
505 dump_location (buffer
, BLOCK_SOURCE_LOCATION (block
));
507 newline_and_indent (buffer
, spc
+ 2);
509 if (BLOCK_SUPERCONTEXT (block
))
511 pp_string (buffer
, "SUPERCONTEXT: ");
512 dump_generic_node (buffer
, BLOCK_SUPERCONTEXT (block
), 0,
513 flags
| TDF_SLIM
, false);
514 newline_and_indent (buffer
, spc
+ 2);
517 if (BLOCK_SUBBLOCKS (block
))
519 pp_string (buffer
, "SUBBLOCKS: ");
520 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
522 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
523 pp_string (buffer
, " ");
525 newline_and_indent (buffer
, spc
+ 2);
528 if (BLOCK_CHAIN (block
))
530 pp_string (buffer
, "SIBLINGS: ");
531 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
533 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
534 pp_string (buffer
, " ");
536 newline_and_indent (buffer
, spc
+ 2);
539 if (BLOCK_VARS (block
))
541 pp_string (buffer
, "VARS: ");
542 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
544 dump_generic_node (buffer
, t
, 0, flags
, false);
545 pp_string (buffer
, " ");
547 newline_and_indent (buffer
, spc
+ 2);
550 if (VEC_length (tree
, BLOCK_NONLOCALIZED_VARS (block
)) > 0)
553 VEC(tree
,gc
) *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
555 pp_string (buffer
, "NONLOCALIZED_VARS: ");
556 FOR_EACH_VEC_ELT (tree
, nlv
, i
, t
)
558 dump_generic_node (buffer
, t
, 0, flags
, false);
559 pp_string (buffer
, " ");
561 newline_and_indent (buffer
, spc
+ 2);
564 if (BLOCK_ABSTRACT_ORIGIN (block
))
566 pp_string (buffer
, "ABSTRACT_ORIGIN: ");
567 dump_generic_node (buffer
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
568 flags
| TDF_SLIM
, false);
569 newline_and_indent (buffer
, spc
+ 2);
572 if (BLOCK_FRAGMENT_ORIGIN (block
))
574 pp_string (buffer
, "FRAGMENT_ORIGIN: ");
575 dump_generic_node (buffer
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
576 flags
| TDF_SLIM
, false);
577 newline_and_indent (buffer
, spc
+ 2);
580 if (BLOCK_FRAGMENT_CHAIN (block
))
582 pp_string (buffer
, "FRAGMENT_CHAIN: ");
583 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
585 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
586 pp_string (buffer
, " ");
588 newline_and_indent (buffer
, spc
+ 2);
593 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
594 indent. FLAGS specifies details to show in the dump (see TDF_* in
595 tree-pass.h). If IS_STMT is true, the object printed is considered
596 to be a statement and it is terminated by ';' if appropriate. */
599 dump_generic_node (pretty_printer
*buffer
, tree node
, int spc
, int flags
,
607 if (node
== NULL_TREE
)
610 is_expr
= EXPR_P (node
);
612 if (is_stmt
&& (flags
& TDF_STMTADDR
))
613 pp_printf (buffer
, "<&%p> ", (void *)node
);
615 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
616 dump_location (buffer
, EXPR_LOCATION (node
));
618 switch (TREE_CODE (node
))
621 pp_string (buffer
, "<<< error >>>");
624 case IDENTIFIER_NODE
:
625 pp_tree_identifier (buffer
, node
);
629 while (node
&& node
!= error_mark_node
)
631 if (TREE_PURPOSE (node
))
633 dump_generic_node (buffer
, TREE_PURPOSE (node
), spc
, flags
, false);
636 dump_generic_node (buffer
, TREE_VALUE (node
), spc
, flags
, false);
637 node
= TREE_CHAIN (node
);
638 if (node
&& TREE_CODE (node
) == TREE_LIST
)
640 pp_character (buffer
, ',');
647 dump_generic_node (buffer
, BINFO_TYPE (node
), spc
, flags
, false);
653 if (TREE_VEC_LENGTH (node
) > 0)
655 size_t len
= TREE_VEC_LENGTH (node
);
656 for (i
= 0; i
< len
- 1; i
++)
658 dump_generic_node (buffer
, TREE_VEC_ELT (node
, i
), spc
, flags
,
660 pp_character (buffer
, ',');
663 dump_generic_node (buffer
, TREE_VEC_ELT (node
, len
- 1), spc
,
672 case FIXED_POINT_TYPE
:
678 unsigned int quals
= TYPE_QUALS (node
);
679 enum tree_code_class tclass
;
681 if (quals
& TYPE_QUAL_CONST
)
682 pp_string (buffer
, "const ");
683 else if (quals
& TYPE_QUAL_VOLATILE
)
684 pp_string (buffer
, "volatile ");
685 else if (quals
& TYPE_QUAL_RESTRICT
)
686 pp_string (buffer
, "restrict ");
688 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
690 pp_string (buffer
, "<address-space-");
691 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
692 pp_string (buffer
, "> ");
695 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
697 if (tclass
== tcc_declaration
)
699 if (DECL_NAME (node
))
700 dump_decl_name (buffer
, node
, flags
);
702 pp_string (buffer
, "<unnamed type decl>");
704 else if (tclass
== tcc_type
)
706 if (TYPE_NAME (node
))
708 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
709 pp_tree_identifier (buffer
, TYPE_NAME (node
));
710 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
711 && DECL_NAME (TYPE_NAME (node
)))
712 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
714 pp_string (buffer
, "<unnamed type>");
716 else if (TREE_CODE (node
) == VECTOR_TYPE
)
718 pp_string (buffer
, "vector");
719 pp_character (buffer
, '(');
720 pp_wide_integer (buffer
, TYPE_VECTOR_SUBPARTS (node
));
721 pp_string (buffer
, ") ");
722 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
724 else if (TREE_CODE (node
) == INTEGER_TYPE
)
726 pp_string (buffer
, (TYPE_UNSIGNED (node
)
727 ? "<unnamed-unsigned:"
728 : "<unnamed-signed:"));
729 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
730 pp_string (buffer
, ">");
732 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
734 pp_string (buffer
, "__complex__ ");
735 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
737 else if (TREE_CODE (node
) == REAL_TYPE
)
739 pp_string (buffer
, "<float:");
740 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
741 pp_string (buffer
, ">");
743 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
745 pp_string (buffer
, "<fixed-point-");
746 pp_string (buffer
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
747 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
748 pp_string (buffer
, ">");
750 else if (TREE_CODE (node
) == VOID_TYPE
)
751 pp_string (buffer
, "void");
753 pp_string (buffer
, "<unnamed type>");
760 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
762 if (TREE_TYPE (node
) == NULL
)
764 pp_string (buffer
, str
);
765 pp_string (buffer
, "<null type>");
767 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
769 tree fnode
= TREE_TYPE (node
);
771 dump_generic_node (buffer
, TREE_TYPE (fnode
), spc
, flags
, false);
773 pp_character (buffer
, '(');
774 pp_string (buffer
, str
);
775 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
776 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
777 else if (flags
& TDF_NOUID
)
778 pp_printf (buffer
, "<Txxxx>");
780 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
782 pp_character (buffer
, ')');
783 dump_function_declaration (buffer
, fnode
, spc
, flags
);
787 unsigned int quals
= TYPE_QUALS (node
);
789 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
791 pp_string (buffer
, str
);
793 if (quals
& TYPE_QUAL_CONST
)
794 pp_string (buffer
, " const");
795 if (quals
& TYPE_QUAL_VOLATILE
)
796 pp_string (buffer
, " volatile");
797 if (quals
& TYPE_QUAL_RESTRICT
)
798 pp_string (buffer
, " restrict");
800 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
802 pp_string (buffer
, " <address-space-");
803 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
804 pp_string (buffer
, ">");
807 if (TYPE_REF_CAN_ALIAS_ALL (node
))
808 pp_string (buffer
, " {ref-all}");
818 if (integer_zerop (TREE_OPERAND (node
, 1))
819 /* Dump the types of INTEGER_CSTs explicitly, for we can't
820 infer them and MEM_ATTR caching will share MEM_REFs
821 with differently-typed op0s. */
822 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
823 /* Released SSA_NAMES have no TREE_TYPE. */
824 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
825 /* Same pointer types, but ignoring POINTER_TYPE vs.
827 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
828 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
829 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
830 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
831 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
832 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
833 /* Same value types ignoring qualifiers. */
834 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
836 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))))
838 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
840 pp_string (buffer
, "*");
841 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
845 dump_generic_node (buffer
,
846 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
853 pp_string (buffer
, "MEM[");
854 pp_string (buffer
, "(");
855 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
856 dump_generic_node (buffer
, ptype
,
857 spc
, flags
| TDF_SLIM
, false);
858 pp_string (buffer
, ")");
859 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
861 if (!integer_zerop (TREE_OPERAND (node
, 1)))
863 pp_string (buffer
, " + ");
864 dump_generic_node (buffer
, TREE_OPERAND (node
, 1),
867 pp_string (buffer
, "]");
874 const char *sep
= "";
877 pp_string (buffer
, "MEM[");
879 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
881 pp_string (buffer
, sep
);
883 pp_string (buffer
, "symbol: ");
884 dump_generic_node (buffer
, TREE_OPERAND (TMR_BASE (node
), 0),
889 pp_string (buffer
, sep
);
891 pp_string (buffer
, "base: ");
892 dump_generic_node (buffer
, TMR_BASE (node
), spc
, flags
, false);
894 tmp
= TMR_INDEX2 (node
);
897 pp_string (buffer
, sep
);
899 pp_string (buffer
, "base: ");
900 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
902 tmp
= TMR_INDEX (node
);
905 pp_string (buffer
, sep
);
907 pp_string (buffer
, "index: ");
908 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
910 tmp
= TMR_STEP (node
);
913 pp_string (buffer
, sep
);
915 pp_string (buffer
, "step: ");
916 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
918 tmp
= TMR_OFFSET (node
);
921 pp_string (buffer
, sep
);
923 pp_string (buffer
, "offset: ");
924 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
926 pp_string (buffer
, "]");
934 /* Print the innermost component type. */
935 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
936 tmp
= TREE_TYPE (tmp
))
938 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
940 /* Print the dimensions. */
941 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
942 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
948 case QUAL_UNION_TYPE
:
950 unsigned int quals
= TYPE_QUALS (node
);
952 if (quals
& TYPE_QUAL_CONST
)
953 pp_string (buffer
, "const ");
954 if (quals
& TYPE_QUAL_VOLATILE
)
955 pp_string (buffer
, "volatile ");
957 /* Print the name of the structure. */
958 if (TREE_CODE (node
) == RECORD_TYPE
)
959 pp_string (buffer
, "struct ");
960 else if (TREE_CODE (node
) == UNION_TYPE
)
961 pp_string (buffer
, "union ");
963 if (TYPE_NAME (node
))
964 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, flags
, false);
965 else if (!(flags
& TDF_SLIM
))
966 /* FIXME: If we eliminate the 'else' above and attempt
967 to show the fields for named types, we may get stuck
968 following a cycle of pointers to structs. The alleged
969 self-reference check in print_struct_decl will not detect
970 cycles involving more than one pointer or struct type. */
971 print_struct_decl (buffer
, node
, spc
, flags
);
980 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
982 /* In the case of a pointer, one may want to divide by the
983 size of the pointed-to type. Unfortunately, this not
984 straightforward. The C front-end maps expressions
989 in such a way that the two INTEGER_CST nodes for "5" have
990 different values but identical types. In the latter
991 case, the 5 is multiplied by sizeof (int) in c-common.c
992 (pointer_int_sum) to convert it to a byte address, and
993 yet the type of the node is left unchanged. Argh. What
994 is consistent though is that the number value corresponds
995 to bytes (UNITS) offset.
997 NB: Neither of the following divisors can be trivially
998 used to recover the original literal:
1000 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1001 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1002 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
1003 pp_string (buffer
, "B"); /* pseudo-unit */
1005 else if (host_integerp (node
, 0))
1006 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
1007 else if (host_integerp (node
, 1))
1008 pp_unsigned_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
1012 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (val
);
1013 HOST_WIDE_INT high
= TREE_INT_CST_HIGH (val
);
1015 if (tree_int_cst_sgn (val
) < 0)
1017 pp_character (buffer
, '-');
1018 high
= ~high
+ !low
;
1021 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
1023 sprintf (pp_buffer (buffer
)->digit_buffer
,
1024 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
1025 (unsigned HOST_WIDE_INT
) high
, low
);
1026 pp_string (buffer
, pp_buffer (buffer
)->digit_buffer
);
1031 /* Code copied from print_node. */
1034 if (TREE_OVERFLOW (node
))
1035 pp_string (buffer
, " overflow");
1037 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
1038 d
= TREE_REAL_CST (node
);
1039 if (REAL_VALUE_ISINF (d
))
1040 pp_string (buffer
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1041 else if (REAL_VALUE_ISNAN (d
))
1042 pp_string (buffer
, " Nan");
1046 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1047 pp_string (buffer
, string
);
1052 unsigned char *p
= (unsigned char *) &TREE_REAL_CST (node
);
1053 pp_string (buffer
, "0x");
1054 for (i
= 0; i
< sizeof TREE_REAL_CST (node
); i
++)
1055 output_formatted_integer (buffer
, "%02x", *p
++);
1064 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1065 pp_string (buffer
, string
);
1070 pp_string (buffer
, "__complex__ (");
1071 dump_generic_node (buffer
, TREE_REALPART (node
), spc
, flags
, false);
1072 pp_string (buffer
, ", ");
1073 dump_generic_node (buffer
, TREE_IMAGPART (node
), spc
, flags
, false);
1074 pp_string (buffer
, ")");
1078 pp_string (buffer
, "\"");
1079 pretty_print_string (buffer
, TREE_STRING_POINTER (node
));
1080 pp_string (buffer
, "\"");
1086 pp_string (buffer
, "{ ");
1087 for (elt
= TREE_VECTOR_CST_ELTS (node
); elt
; elt
= TREE_CHAIN (elt
))
1089 dump_generic_node (buffer
, TREE_VALUE (elt
), spc
, flags
, false);
1090 if (TREE_CHAIN (elt
))
1091 pp_string (buffer
, ", ");
1093 pp_string (buffer
, " }");
1099 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1101 if (TREE_CODE (node
) == METHOD_TYPE
)
1103 if (TYPE_METHOD_BASETYPE (node
))
1104 dump_decl_name (buffer
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1107 pp_string (buffer
, "<null method basetype>");
1108 pp_string (buffer
, "::");
1110 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1111 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
1112 else if (flags
& TDF_NOUID
)
1113 pp_printf (buffer
, "<Txxxx>");
1115 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
1116 dump_function_declaration (buffer
, node
, spc
, flags
);
1121 dump_decl_name (buffer
, node
, flags
);
1125 if (DECL_NAME (node
))
1126 dump_decl_name (buffer
, node
, flags
);
1127 else if (LABEL_DECL_UID (node
) != -1)
1128 pp_printf (buffer
, "<L%d>", (int) LABEL_DECL_UID (node
));
1131 if (flags
& TDF_NOUID
)
1132 pp_string (buffer
, "<D.xxxx>");
1134 pp_printf (buffer
, "<D.%u>", DECL_UID (node
));
1139 if (DECL_IS_BUILTIN (node
))
1141 /* Don't print the declaration of built-in types. */
1144 if (DECL_NAME (node
))
1145 dump_decl_name (buffer
, node
, flags
);
1146 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1148 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1149 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1150 && TYPE_METHODS (TREE_TYPE (node
)))
1152 /* The type is a c++ class: all structures have at least
1154 pp_string (buffer
, "class ");
1155 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1160 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1161 ? "union" : "struct "));
1162 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1166 pp_string (buffer
, "<anon>");
1172 case DEBUG_EXPR_DECL
:
1173 case NAMESPACE_DECL
:
1174 dump_decl_name (buffer
, node
, flags
);
1178 pp_string (buffer
, "<retval>");
1182 op0
= TREE_OPERAND (node
, 0);
1185 && (TREE_CODE (op0
) == INDIRECT_REF
1186 || (TREE_CODE (op0
) == MEM_REF
1187 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1188 && integer_zerop (TREE_OPERAND (op0
, 1))
1189 /* Dump the types of INTEGER_CSTs explicitly, for we
1190 can't infer them and MEM_ATTR caching will share
1191 MEM_REFs with differently-typed op0s. */
1192 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1193 /* Released SSA_NAMES have no TREE_TYPE. */
1194 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1195 /* Same pointer types, but ignoring POINTER_TYPE vs.
1197 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1198 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1199 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1200 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1201 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1202 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1203 /* Same value types ignoring qualifiers. */
1204 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1205 == TYPE_MAIN_VARIANT
1206 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))))))
1208 op0
= TREE_OPERAND (op0
, 0);
1211 if (op_prio (op0
) < op_prio (node
))
1212 pp_character (buffer
, '(');
1213 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1214 if (op_prio (op0
) < op_prio (node
))
1215 pp_character (buffer
, ')');
1216 pp_string (buffer
, str
);
1217 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1218 op0
= component_ref_field_offset (node
);
1219 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1221 pp_string (buffer
, "{off: ");
1222 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1223 pp_character (buffer
, '}');
1228 pp_string (buffer
, "BIT_FIELD_REF <");
1229 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1230 pp_string (buffer
, ", ");
1231 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1232 pp_string (buffer
, ", ");
1233 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1234 pp_string (buffer
, ">");
1238 case ARRAY_RANGE_REF
:
1239 op0
= TREE_OPERAND (node
, 0);
1240 if (op_prio (op0
) < op_prio (node
))
1241 pp_character (buffer
, '(');
1242 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1243 if (op_prio (op0
) < op_prio (node
))
1244 pp_character (buffer
, ')');
1245 pp_character (buffer
, '[');
1246 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1247 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1248 pp_string (buffer
, " ...");
1249 pp_character (buffer
, ']');
1251 op0
= array_ref_low_bound (node
);
1252 op1
= array_ref_element_size (node
);
1254 if (!integer_zerop (op0
)
1255 || TREE_OPERAND (node
, 2)
1256 || TREE_OPERAND (node
, 3))
1258 pp_string (buffer
, "{lb: ");
1259 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1260 pp_string (buffer
, " sz: ");
1261 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1262 pp_character (buffer
, '}');
1268 unsigned HOST_WIDE_INT ix
;
1270 bool is_struct_init
= false;
1271 bool is_array_init
= false;
1272 double_int curidx
= double_int_zero
;
1273 pp_character (buffer
, '{');
1274 if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1275 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1276 is_struct_init
= true;
1277 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
1278 && TYPE_DOMAIN (TREE_TYPE (node
))
1279 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
1280 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
1283 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
1284 is_array_init
= true;
1285 curidx
= tree_to_double_int (minv
);
1287 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1293 pp_character (buffer
, '.');
1294 dump_generic_node (buffer
, field
, spc
, flags
, false);
1295 pp_character (buffer
, '=');
1297 else if (is_array_init
1298 && (TREE_CODE (field
) != INTEGER_CST
1299 || !double_int_equal_p (tree_to_double_int (field
),
1302 pp_character (buffer
, '[');
1303 if (TREE_CODE (field
) == RANGE_EXPR
)
1305 dump_generic_node (buffer
, TREE_OPERAND (field
, 0), spc
,
1307 pp_string (buffer
, " ... ");
1308 dump_generic_node (buffer
, TREE_OPERAND (field
, 1), spc
,
1310 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
1311 curidx
= tree_to_double_int (TREE_OPERAND (field
, 1));
1314 dump_generic_node (buffer
, field
, spc
, flags
, false);
1315 if (TREE_CODE (field
) == INTEGER_CST
)
1316 curidx
= tree_to_double_int (field
);
1317 pp_string (buffer
, "]=");
1321 curidx
= double_int_add (curidx
, double_int_one
);
1322 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1323 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1324 val
= TREE_OPERAND (val
, 0);
1325 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1326 dump_decl_name (buffer
, val
, flags
);
1328 dump_generic_node (buffer
, val
, spc
, flags
, false);
1329 if (ix
!= VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (node
)) - 1)
1331 pp_character (buffer
, ',');
1335 pp_character (buffer
, '}');
1342 if (flags
& TDF_SLIM
)
1344 pp_string (buffer
, "<COMPOUND_EXPR>");
1348 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1349 spc
, flags
, !(flags
& TDF_SLIM
));
1350 if (flags
& TDF_SLIM
)
1351 newline_and_indent (buffer
, spc
);
1354 pp_character (buffer
, ',');
1358 for (tp
= &TREE_OPERAND (node
, 1);
1359 TREE_CODE (*tp
) == COMPOUND_EXPR
;
1360 tp
= &TREE_OPERAND (*tp
, 1))
1362 dump_generic_node (buffer
, TREE_OPERAND (*tp
, 0),
1363 spc
, flags
, !(flags
& TDF_SLIM
));
1364 if (flags
& TDF_SLIM
)
1365 newline_and_indent (buffer
, spc
);
1368 pp_character (buffer
, ',');
1373 dump_generic_node (buffer
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
1377 case STATEMENT_LIST
:
1379 tree_stmt_iterator si
;
1382 if (flags
& TDF_SLIM
)
1384 pp_string (buffer
, "<STATEMENT_LIST>");
1388 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
1391 newline_and_indent (buffer
, spc
);
1394 dump_generic_node (buffer
, tsi_stmt (si
), spc
, flags
, true);
1401 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
,
1404 pp_character (buffer
, '=');
1405 if (TREE_CODE (node
) == MODIFY_EXPR
1406 && MOVE_NONTEMPORAL (node
))
1407 pp_string (buffer
, "{nt}");
1409 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
,
1414 pp_string (buffer
, "TARGET_EXPR <");
1415 dump_generic_node (buffer
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
1416 pp_character (buffer
, ',');
1418 dump_generic_node (buffer
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
1419 pp_character (buffer
, '>');
1423 print_declaration (buffer
, DECL_EXPR_DECL (node
), spc
, flags
);
1428 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
1430 pp_string (buffer
, "if (");
1431 dump_generic_node (buffer
, COND_EXPR_COND (node
), spc
, flags
, false);
1432 pp_character (buffer
, ')');
1433 /* The lowered cond_exprs should always be printed in full. */
1434 if (COND_EXPR_THEN (node
)
1435 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
1436 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
1437 && COND_EXPR_ELSE (node
)
1438 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
1439 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
1442 dump_generic_node (buffer
, COND_EXPR_THEN (node
),
1444 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1446 pp_string (buffer
, " else ");
1447 dump_generic_node (buffer
, COND_EXPR_ELSE (node
),
1451 else if (!(flags
& TDF_SLIM
))
1453 /* Output COND_EXPR_THEN. */
1454 if (COND_EXPR_THEN (node
))
1456 newline_and_indent (buffer
, spc
+2);
1457 pp_character (buffer
, '{');
1458 newline_and_indent (buffer
, spc
+4);
1459 dump_generic_node (buffer
, COND_EXPR_THEN (node
), spc
+4,
1461 newline_and_indent (buffer
, spc
+2);
1462 pp_character (buffer
, '}');
1465 /* Output COND_EXPR_ELSE. */
1466 if (COND_EXPR_ELSE (node
)
1467 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1469 newline_and_indent (buffer
, spc
);
1470 pp_string (buffer
, "else");
1471 newline_and_indent (buffer
, spc
+2);
1472 pp_character (buffer
, '{');
1473 newline_and_indent (buffer
, spc
+4);
1474 dump_generic_node (buffer
, COND_EXPR_ELSE (node
), spc
+4,
1476 newline_and_indent (buffer
, spc
+2);
1477 pp_character (buffer
, '}');
1484 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1486 pp_character (buffer
, '?');
1488 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1490 pp_character (buffer
, ':');
1492 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1497 pp_character (buffer
, '{');
1498 if (!(flags
& TDF_SLIM
))
1500 if (BIND_EXPR_VARS (node
))
1502 pp_newline (buffer
);
1504 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
1506 print_declaration (buffer
, op0
, spc
+2, flags
);
1507 pp_newline (buffer
);
1511 newline_and_indent (buffer
, spc
+2);
1512 dump_generic_node (buffer
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
1513 newline_and_indent (buffer
, spc
);
1514 pp_character (buffer
, '}');
1520 print_call_name (buffer
, CALL_EXPR_FN (node
), flags
);
1522 /* Print parameters. */
1524 pp_character (buffer
, '(');
1527 call_expr_arg_iterator iter
;
1528 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
1530 dump_generic_node (buffer
, arg
, spc
, flags
, false);
1531 if (more_call_expr_args_p (&iter
))
1533 pp_character (buffer
, ',');
1538 if (CALL_EXPR_VA_ARG_PACK (node
))
1540 if (call_expr_nargs (node
) > 0)
1542 pp_character (buffer
, ',');
1545 pp_string (buffer
, "__builtin_va_arg_pack ()");
1547 pp_character (buffer
, ')');
1549 op1
= CALL_EXPR_STATIC_CHAIN (node
);
1552 pp_string (buffer
, " [static-chain: ");
1553 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1554 pp_character (buffer
, ']');
1557 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
1558 pp_string (buffer
, " [return slot optimization]");
1559 if (CALL_EXPR_TAILCALL (node
))
1560 pp_string (buffer
, " [tail call]");
1563 case WITH_CLEANUP_EXPR
:
1567 case CLEANUP_POINT_EXPR
:
1568 pp_string (buffer
, "<<cleanup_point ");
1569 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1570 pp_string (buffer
, ">>");
1573 case PLACEHOLDER_EXPR
:
1574 pp_string (buffer
, "<PLACEHOLDER_EXPR ");
1575 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1576 pp_character (buffer
, '>');
1579 /* Binary arithmetic and logic expressions. */
1580 case WIDEN_SUM_EXPR
:
1581 case WIDEN_MULT_EXPR
:
1584 case POINTER_PLUS_EXPR
:
1586 case TRUNC_DIV_EXPR
:
1588 case FLOOR_DIV_EXPR
:
1589 case ROUND_DIV_EXPR
:
1590 case TRUNC_MOD_EXPR
:
1592 case FLOOR_MOD_EXPR
:
1593 case ROUND_MOD_EXPR
:
1595 case EXACT_DIV_EXPR
:
1600 case VEC_LSHIFT_EXPR
:
1601 case VEC_RSHIFT_EXPR
:
1605 case TRUTH_ANDIF_EXPR
:
1606 case TRUTH_ORIF_EXPR
:
1607 case TRUTH_AND_EXPR
:
1609 case TRUTH_XOR_EXPR
:
1623 case UNORDERED_EXPR
:
1625 const char *op
= op_symbol (node
);
1626 op0
= TREE_OPERAND (node
, 0);
1627 op1
= TREE_OPERAND (node
, 1);
1629 /* When the operands are expressions with less priority,
1630 keep semantics of the tree representation. */
1631 if (op_prio (op0
) <= op_prio (node
))
1633 pp_character (buffer
, '(');
1634 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1635 pp_character (buffer
, ')');
1638 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1641 pp_string (buffer
, op
);
1644 /* When the operands are expressions with less priority,
1645 keep semantics of the tree representation. */
1646 if (op_prio (op1
) <= op_prio (node
))
1648 pp_character (buffer
, '(');
1649 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1650 pp_character (buffer
, ')');
1653 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1657 /* Unary arithmetic and logic expressions. */
1660 case TRUTH_NOT_EXPR
:
1662 case PREDECREMENT_EXPR
:
1663 case PREINCREMENT_EXPR
:
1665 if (TREE_CODE (node
) == ADDR_EXPR
1666 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
1667 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
1668 ; /* Do not output '&' for strings and function pointers. */
1670 pp_string (buffer
, op_symbol (node
));
1672 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1674 pp_character (buffer
, '(');
1675 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1676 pp_character (buffer
, ')');
1679 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1682 case POSTDECREMENT_EXPR
:
1683 case POSTINCREMENT_EXPR
:
1684 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1686 pp_character (buffer
, '(');
1687 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1688 pp_character (buffer
, ')');
1691 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1692 pp_string (buffer
, op_symbol (node
));
1696 pp_string (buffer
, "MIN_EXPR <");
1697 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1698 pp_string (buffer
, ", ");
1699 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1700 pp_character (buffer
, '>');
1704 pp_string (buffer
, "MAX_EXPR <");
1705 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1706 pp_string (buffer
, ", ");
1707 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1708 pp_character (buffer
, '>');
1712 pp_string (buffer
, "ABS_EXPR <");
1713 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1714 pp_character (buffer
, '>');
1721 case ADDR_SPACE_CONVERT_EXPR
:
1722 case FIXED_CONVERT_EXPR
:
1723 case FIX_TRUNC_EXPR
:
1726 type
= TREE_TYPE (node
);
1727 op0
= TREE_OPERAND (node
, 0);
1728 if (type
!= TREE_TYPE (op0
))
1730 pp_character (buffer
, '(');
1731 dump_generic_node (buffer
, type
, spc
, flags
, false);
1732 pp_string (buffer
, ") ");
1734 if (op_prio (op0
) < op_prio (node
))
1735 pp_character (buffer
, '(');
1736 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1737 if (op_prio (op0
) < op_prio (node
))
1738 pp_character (buffer
, ')');
1741 case VIEW_CONVERT_EXPR
:
1742 pp_string (buffer
, "VIEW_CONVERT_EXPR<");
1743 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1744 pp_string (buffer
, ">(");
1745 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1746 pp_character (buffer
, ')');
1750 pp_string (buffer
, "((");
1751 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1752 pp_string (buffer
, "))");
1755 case NON_LVALUE_EXPR
:
1756 pp_string (buffer
, "NON_LVALUE_EXPR <");
1757 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1758 pp_character (buffer
, '>');
1762 pp_string (buffer
, "SAVE_EXPR <");
1763 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1764 pp_character (buffer
, '>');
1768 pp_string (buffer
, "COMPLEX_EXPR <");
1769 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1770 pp_string (buffer
, ", ");
1771 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1772 pp_string (buffer
, ">");
1776 pp_string (buffer
, "CONJ_EXPR <");
1777 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1778 pp_string (buffer
, ">");
1782 pp_string (buffer
, "REALPART_EXPR <");
1783 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1784 pp_string (buffer
, ">");
1788 pp_string (buffer
, "IMAGPART_EXPR <");
1789 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1790 pp_string (buffer
, ">");
1794 pp_string (buffer
, "VA_ARG_EXPR <");
1795 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1796 pp_string (buffer
, ">");
1799 case TRY_FINALLY_EXPR
:
1800 case TRY_CATCH_EXPR
:
1801 pp_string (buffer
, "try");
1802 newline_and_indent (buffer
, spc
+2);
1803 pp_string (buffer
, "{");
1804 newline_and_indent (buffer
, spc
+4);
1805 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
1806 newline_and_indent (buffer
, spc
+2);
1807 pp_string (buffer
, "}");
1808 newline_and_indent (buffer
, spc
);
1810 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
1811 newline_and_indent (buffer
, spc
+2);
1812 pp_string (buffer
, "{");
1813 newline_and_indent (buffer
, spc
+4);
1814 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
1815 newline_and_indent (buffer
, spc
+2);
1816 pp_string (buffer
, "}");
1821 pp_string (buffer
, "catch (");
1822 dump_generic_node (buffer
, CATCH_TYPES (node
), spc
+2, flags
, false);
1823 pp_string (buffer
, ")");
1824 newline_and_indent (buffer
, spc
+2);
1825 pp_string (buffer
, "{");
1826 newline_and_indent (buffer
, spc
+4);
1827 dump_generic_node (buffer
, CATCH_BODY (node
), spc
+4, flags
, true);
1828 newline_and_indent (buffer
, spc
+2);
1829 pp_string (buffer
, "}");
1833 case EH_FILTER_EXPR
:
1834 pp_string (buffer
, "<<<eh_filter (");
1835 dump_generic_node (buffer
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
1836 pp_string (buffer
, ")>>>");
1837 newline_and_indent (buffer
, spc
+2);
1838 pp_string (buffer
, "{");
1839 newline_and_indent (buffer
, spc
+4);
1840 dump_generic_node (buffer
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
1841 newline_and_indent (buffer
, spc
+2);
1842 pp_string (buffer
, "}");
1847 op0
= TREE_OPERAND (node
, 0);
1848 /* If this is for break or continue, don't bother printing it. */
1849 if (DECL_NAME (op0
))
1851 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
1852 if (strcmp (name
, "break") == 0
1853 || strcmp (name
, "continue") == 0)
1856 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1857 pp_character (buffer
, ':');
1858 if (DECL_NONLOCAL (op0
))
1859 pp_string (buffer
, " [non-local]");
1863 pp_string (buffer
, "while (1)");
1864 if (!(flags
& TDF_SLIM
))
1866 newline_and_indent (buffer
, spc
+2);
1867 pp_character (buffer
, '{');
1868 newline_and_indent (buffer
, spc
+4);
1869 dump_generic_node (buffer
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
1870 newline_and_indent (buffer
, spc
+2);
1871 pp_character (buffer
, '}');
1877 pp_string (buffer
, "// predicted ");
1878 if (PREDICT_EXPR_OUTCOME (node
))
1879 pp_string (buffer
, "likely by ");
1881 pp_string (buffer
, "unlikely by ");
1882 pp_string (buffer
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
1883 pp_string (buffer
, " predictor.");
1887 pp_string (buffer
, "return");
1888 op0
= TREE_OPERAND (node
, 0);
1892 if (TREE_CODE (op0
) == MODIFY_EXPR
)
1893 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1),
1896 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1901 pp_string (buffer
, "if (");
1902 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1903 pp_string (buffer
, ") break");
1907 pp_string (buffer
, "switch (");
1908 dump_generic_node (buffer
, SWITCH_COND (node
), spc
, flags
, false);
1909 pp_character (buffer
, ')');
1910 if (!(flags
& TDF_SLIM
))
1912 newline_and_indent (buffer
, spc
+2);
1913 pp_character (buffer
, '{');
1914 if (SWITCH_BODY (node
))
1916 newline_and_indent (buffer
, spc
+4);
1917 dump_generic_node (buffer
, SWITCH_BODY (node
), spc
+4, flags
,
1922 tree vec
= SWITCH_LABELS (node
);
1923 size_t i
, n
= TREE_VEC_LENGTH (vec
);
1924 for (i
= 0; i
< n
; ++i
)
1926 tree elt
= TREE_VEC_ELT (vec
, i
);
1927 newline_and_indent (buffer
, spc
+4);
1930 dump_generic_node (buffer
, elt
, spc
+4, flags
, false);
1931 pp_string (buffer
, " goto ");
1932 dump_generic_node (buffer
, CASE_LABEL (elt
), spc
+4,
1934 pp_semicolon (buffer
);
1937 pp_string (buffer
, "case ???: goto ???;");
1940 newline_and_indent (buffer
, spc
+2);
1941 pp_character (buffer
, '}');
1947 op0
= GOTO_DESTINATION (node
);
1948 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
1950 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
1951 if (strcmp (name
, "break") == 0
1952 || strcmp (name
, "continue") == 0)
1954 pp_string (buffer
, name
);
1958 pp_string (buffer
, "goto ");
1959 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1963 pp_string (buffer
, "__asm__");
1964 if (ASM_VOLATILE_P (node
))
1965 pp_string (buffer
, " __volatile__");
1966 pp_character (buffer
, '(');
1967 dump_generic_node (buffer
, ASM_STRING (node
), spc
, flags
, false);
1968 pp_character (buffer
, ':');
1969 dump_generic_node (buffer
, ASM_OUTPUTS (node
), spc
, flags
, false);
1970 pp_character (buffer
, ':');
1971 dump_generic_node (buffer
, ASM_INPUTS (node
), spc
, flags
, false);
1972 if (ASM_CLOBBERS (node
))
1974 pp_character (buffer
, ':');
1975 dump_generic_node (buffer
, ASM_CLOBBERS (node
), spc
, flags
, false);
1977 pp_string (buffer
, ")");
1980 case CASE_LABEL_EXPR
:
1981 if (CASE_LOW (node
) && CASE_HIGH (node
))
1983 pp_string (buffer
, "case ");
1984 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
1985 pp_string (buffer
, " ... ");
1986 dump_generic_node (buffer
, CASE_HIGH (node
), spc
, flags
, false);
1988 else if (CASE_LOW (node
))
1990 pp_string (buffer
, "case ");
1991 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
1994 pp_string (buffer
, "default");
1995 pp_character (buffer
, ':');
1999 pp_string (buffer
, "OBJ_TYPE_REF(");
2000 dump_generic_node (buffer
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2001 pp_character (buffer
, ';');
2002 dump_generic_node (buffer
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2003 pp_character (buffer
, '-');
2004 pp_character (buffer
, '>');
2005 dump_generic_node (buffer
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2006 pp_character (buffer
, ')');
2010 dump_generic_node (buffer
, SSA_NAME_VAR (node
), spc
, flags
, false);
2011 pp_string (buffer
, "_");
2012 pp_decimal_int (buffer
, SSA_NAME_VERSION (node
));
2013 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2014 pp_string (buffer
, "(ab)");
2015 else if (SSA_NAME_IS_DEFAULT_DEF (node
))
2016 pp_string (buffer
, "(D)");
2019 case WITH_SIZE_EXPR
:
2020 pp_string (buffer
, "WITH_SIZE_EXPR <");
2021 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2022 pp_string (buffer
, ", ");
2023 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2024 pp_string (buffer
, ">");
2028 pp_string (buffer
, "ASSERT_EXPR <");
2029 dump_generic_node (buffer
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2030 pp_string (buffer
, ", ");
2031 dump_generic_node (buffer
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2032 pp_string (buffer
, ">");
2036 pp_string (buffer
, "scev_known");
2039 case SCEV_NOT_KNOWN
:
2040 pp_string (buffer
, "scev_not_known");
2043 case POLYNOMIAL_CHREC
:
2044 pp_string (buffer
, "{");
2045 dump_generic_node (buffer
, CHREC_LEFT (node
), spc
, flags
, false);
2046 pp_string (buffer
, ", +, ");
2047 dump_generic_node (buffer
, CHREC_RIGHT (node
), spc
, flags
, false);
2048 pp_string (buffer
, "}_");
2049 dump_generic_node (buffer
, CHREC_VAR (node
), spc
, flags
, false);
2053 case REALIGN_LOAD_EXPR
:
2054 pp_string (buffer
, "REALIGN_LOAD <");
2055 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2056 pp_string (buffer
, ", ");
2057 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2058 pp_string (buffer
, ", ");
2059 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2060 pp_string (buffer
, ">");
2064 pp_string (buffer
, " VEC_COND_EXPR < ");
2065 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2066 pp_string (buffer
, " , ");
2067 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2068 pp_string (buffer
, " , ");
2069 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2070 pp_string (buffer
, " > ");
2074 pp_string (buffer
, " DOT_PROD_EXPR < ");
2075 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2076 pp_string (buffer
, ", ");
2077 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2078 pp_string (buffer
, ", ");
2079 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2080 pp_string (buffer
, " > ");
2083 case WIDEN_MULT_PLUS_EXPR
:
2084 pp_string (buffer
, " WIDEN_MULT_PLUS_EXPR < ");
2085 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2086 pp_string (buffer
, ", ");
2087 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2088 pp_string (buffer
, ", ");
2089 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2090 pp_string (buffer
, " > ");
2093 case WIDEN_MULT_MINUS_EXPR
:
2094 pp_string (buffer
, " WIDEN_MULT_MINUS_EXPR < ");
2095 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2096 pp_string (buffer
, ", ");
2097 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2098 pp_string (buffer
, ", ");
2099 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2100 pp_string (buffer
, " > ");
2104 pp_string (buffer
, " FMA_EXPR < ");
2105 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2106 pp_string (buffer
, ", ");
2107 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2108 pp_string (buffer
, ", ");
2109 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2110 pp_string (buffer
, " > ");
2114 pp_string (buffer
, "#pragma omp parallel");
2115 dump_omp_clauses (buffer
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2118 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2120 newline_and_indent (buffer
, spc
+ 2);
2121 pp_character (buffer
, '{');
2122 newline_and_indent (buffer
, spc
+ 4);
2123 dump_generic_node (buffer
, OMP_BODY (node
), spc
+ 4, flags
, false);
2124 newline_and_indent (buffer
, spc
+ 2);
2125 pp_character (buffer
, '}');
2131 pp_string (buffer
, "#pragma omp task");
2132 dump_omp_clauses (buffer
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2136 pp_string (buffer
, "#pragma omp for");
2137 dump_omp_clauses (buffer
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2139 if (!(flags
& TDF_SLIM
))
2143 if (OMP_FOR_PRE_BODY (node
))
2145 newline_and_indent (buffer
, spc
+ 2);
2146 pp_character (buffer
, '{');
2148 newline_and_indent (buffer
, spc
);
2149 dump_generic_node (buffer
, OMP_FOR_PRE_BODY (node
),
2153 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
2156 newline_and_indent (buffer
, spc
);
2157 pp_string (buffer
, "for (");
2158 dump_generic_node (buffer
, TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
2160 pp_string (buffer
, "; ");
2161 dump_generic_node (buffer
, TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
2163 pp_string (buffer
, "; ");
2164 dump_generic_node (buffer
, TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
2166 pp_string (buffer
, ")");
2168 if (OMP_FOR_BODY (node
))
2170 newline_and_indent (buffer
, spc
+ 2);
2171 pp_character (buffer
, '{');
2172 newline_and_indent (buffer
, spc
+ 4);
2173 dump_generic_node (buffer
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
2175 newline_and_indent (buffer
, spc
+ 2);
2176 pp_character (buffer
, '}');
2178 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
2179 if (OMP_FOR_PRE_BODY (node
))
2182 newline_and_indent (buffer
, spc
+ 2);
2183 pp_character (buffer
, '}');
2190 pp_string (buffer
, "#pragma omp sections");
2191 dump_omp_clauses (buffer
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
2195 pp_string (buffer
, "#pragma omp section");
2199 pp_string (buffer
, "#pragma omp master");
2203 pp_string (buffer
, "#pragma omp ordered");
2207 pp_string (buffer
, "#pragma omp critical");
2208 if (OMP_CRITICAL_NAME (node
))
2211 pp_character (buffer
, '(');
2212 dump_generic_node (buffer
, OMP_CRITICAL_NAME (node
), spc
,
2214 pp_character (buffer
, ')');
2219 pp_string (buffer
, "#pragma omp atomic");
2220 newline_and_indent (buffer
, spc
+ 2);
2221 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2223 pp_character (buffer
, '=');
2225 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2228 case OMP_ATOMIC_READ
:
2229 pp_string (buffer
, "#pragma omp atomic read");
2230 newline_and_indent (buffer
, spc
+ 2);
2231 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2235 case OMP_ATOMIC_CAPTURE_OLD
:
2236 case OMP_ATOMIC_CAPTURE_NEW
:
2237 pp_string (buffer
, "#pragma omp atomic capture");
2238 newline_and_indent (buffer
, spc
+ 2);
2239 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2241 pp_character (buffer
, '=');
2243 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2247 pp_string (buffer
, "#pragma omp single");
2248 dump_omp_clauses (buffer
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
2252 dump_omp_clause (buffer
, node
, spc
, flags
);
2256 case REDUC_MAX_EXPR
:
2257 pp_string (buffer
, " REDUC_MAX_EXPR < ");
2258 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2259 pp_string (buffer
, " > ");
2262 case REDUC_MIN_EXPR
:
2263 pp_string (buffer
, " REDUC_MIN_EXPR < ");
2264 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2265 pp_string (buffer
, " > ");
2268 case REDUC_PLUS_EXPR
:
2269 pp_string (buffer
, " REDUC_PLUS_EXPR < ");
2270 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2271 pp_string (buffer
, " > ");
2274 case VEC_WIDEN_MULT_HI_EXPR
:
2275 pp_string (buffer
, " VEC_WIDEN_MULT_HI_EXPR < ");
2276 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2277 pp_string (buffer
, ", ");
2278 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2279 pp_string (buffer
, " > ");
2282 case VEC_WIDEN_MULT_LO_EXPR
:
2283 pp_string (buffer
, " VEC_WIDEN_MULT_LO_EXPR < ");
2284 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2285 pp_string (buffer
, ", ");
2286 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2287 pp_string (buffer
, " > ");
2290 case VEC_UNPACK_HI_EXPR
:
2291 pp_string (buffer
, " VEC_UNPACK_HI_EXPR < ");
2292 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2293 pp_string (buffer
, " > ");
2296 case VEC_UNPACK_LO_EXPR
:
2297 pp_string (buffer
, " VEC_UNPACK_LO_EXPR < ");
2298 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2299 pp_string (buffer
, " > ");
2302 case VEC_UNPACK_FLOAT_HI_EXPR
:
2303 pp_string (buffer
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2304 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2305 pp_string (buffer
, " > ");
2308 case VEC_UNPACK_FLOAT_LO_EXPR
:
2309 pp_string (buffer
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2310 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2311 pp_string (buffer
, " > ");
2314 case VEC_PACK_TRUNC_EXPR
:
2315 pp_string (buffer
, " VEC_PACK_TRUNC_EXPR < ");
2316 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2317 pp_string (buffer
, ", ");
2318 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2319 pp_string (buffer
, " > ");
2322 case VEC_PACK_SAT_EXPR
:
2323 pp_string (buffer
, " VEC_PACK_SAT_EXPR < ");
2324 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2325 pp_string (buffer
, ", ");
2326 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2327 pp_string (buffer
, " > ");
2330 case VEC_PACK_FIX_TRUNC_EXPR
:
2331 pp_string (buffer
, " VEC_PACK_FIX_TRUNC_EXPR < ");
2332 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2333 pp_string (buffer
, ", ");
2334 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2335 pp_string (buffer
, " > ");
2339 dump_block_node (buffer
, node
, spc
, flags
);
2342 case VEC_EXTRACT_EVEN_EXPR
:
2343 pp_string (buffer
, " VEC_EXTRACT_EVEN_EXPR < ");
2344 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2345 pp_string (buffer
, ", ");
2346 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2347 pp_string (buffer
, " > ");
2350 case VEC_EXTRACT_ODD_EXPR
:
2351 pp_string (buffer
, " VEC_EXTRACT_ODD_EXPR < ");
2352 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2353 pp_string (buffer
, ", ");
2354 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2355 pp_string (buffer
, " > ");
2358 case VEC_INTERLEAVE_HIGH_EXPR
:
2359 pp_string (buffer
, " VEC_INTERLEAVE_HIGH_EXPR < ");
2360 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2361 pp_string (buffer
, ", ");
2362 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2363 pp_string (buffer
, " > ");
2366 case VEC_INTERLEAVE_LOW_EXPR
:
2367 pp_string (buffer
, " VEC_INTERLEAVE_LOW_EXPR < ");
2368 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2369 pp_string (buffer
, ", ");
2370 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2371 pp_string (buffer
, " > ");
2378 if (is_stmt
&& is_expr
)
2379 pp_semicolon (buffer
);
2381 /* If we're building a diagnostic, the formatted text will be written
2382 into BUFFER's stream by the caller; otherwise, write it now. */
2383 if (!(flags
& TDF_DIAGNOSTIC
))
2384 pp_write_text_to_stream (buffer
);
2389 /* Print the declaration of a variable. */
2392 print_declaration (pretty_printer
*buffer
, tree t
, int spc
, int flags
)
2396 if (TREE_CODE (t
) == TYPE_DECL
)
2397 pp_string (buffer
, "typedef ");
2399 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
2400 pp_string (buffer
, "register ");
2402 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
2403 pp_string (buffer
, "extern ");
2404 else if (TREE_STATIC (t
))
2405 pp_string (buffer
, "static ");
2407 /* Print the type and name. */
2408 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
2412 /* Print array's type. */
2413 tmp
= TREE_TYPE (t
);
2414 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
2415 tmp
= TREE_TYPE (tmp
);
2416 dump_generic_node (buffer
, TREE_TYPE (tmp
), spc
, flags
, false);
2418 /* Print variable's name. */
2420 dump_generic_node (buffer
, t
, spc
, flags
, false);
2422 /* Print the dimensions. */
2423 tmp
= TREE_TYPE (t
);
2424 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
2426 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
2427 tmp
= TREE_TYPE (tmp
);
2430 else if (TREE_CODE (t
) == FUNCTION_DECL
)
2432 dump_generic_node (buffer
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
2434 dump_decl_name (buffer
, t
, flags
);
2435 dump_function_declaration (buffer
, TREE_TYPE (t
), spc
, flags
);
2439 /* Print type declaration. */
2440 dump_generic_node (buffer
, TREE_TYPE (t
), spc
, flags
, false);
2442 /* Print variable's name. */
2444 dump_generic_node (buffer
, t
, spc
, flags
, false);
2447 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
2449 pp_string (buffer
, " __asm__ ");
2450 pp_character (buffer
, '(');
2451 dump_generic_node (buffer
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
2452 pp_character (buffer
, ')');
2455 /* The initial value of a function serves to determine whether the function
2456 is declared or defined. So the following does not apply to function
2458 if (TREE_CODE (t
) != FUNCTION_DECL
)
2460 /* Print the initial value. */
2461 if (DECL_INITIAL (t
))
2464 pp_character (buffer
, '=');
2466 dump_generic_node (buffer
, DECL_INITIAL (t
), spc
, flags
, false);
2470 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
2472 pp_string (buffer
, " [value-expr: ");
2473 dump_generic_node (buffer
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
2474 pp_character (buffer
, ']');
2477 pp_character (buffer
, ';');
2481 /* Prints a structure: name, fields, and methods.
2482 FIXME: Still incomplete. */
2485 print_struct_decl (pretty_printer
*buffer
, const_tree node
, int spc
, int flags
)
2487 /* Print the name of the structure. */
2488 if (TYPE_NAME (node
))
2491 if (TREE_CODE (node
) == RECORD_TYPE
)
2492 pp_string (buffer
, "struct ");
2493 else if ((TREE_CODE (node
) == UNION_TYPE
2494 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
2495 pp_string (buffer
, "union ");
2497 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, 0, false);
2500 /* Print the contents of the structure. */
2501 pp_newline (buffer
);
2503 pp_character (buffer
, '{');
2504 pp_newline (buffer
);
2506 /* Print the fields of the structure. */
2509 tmp
= TYPE_FIELDS (node
);
2512 /* Avoid to print recursively the structure. */
2513 /* FIXME : Not implemented correctly...,
2514 what about the case when we have a cycle in the contain graph? ...
2515 Maybe this could be solved by looking at the scope in which the
2516 structure was declared. */
2517 if (TREE_TYPE (tmp
) != node
2518 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
2519 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
2521 print_declaration (buffer
, tmp
, spc
+2, flags
);
2522 pp_newline (buffer
);
2524 tmp
= DECL_CHAIN (tmp
);
2528 pp_character (buffer
, '}');
2531 /* Return the priority of the operator CODE.
2533 From lowest to highest precedence with either left-to-right (L-R)
2534 or right-to-left (R-L) associativity]:
2537 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2549 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2550 15 [L-R] fn() [] -> .
2552 unary +, - and * have higher precedence than the corresponding binary
2556 op_code_prio (enum tree_code code
)
2573 case TRUTH_ORIF_EXPR
:
2576 case TRUTH_AND_EXPR
:
2577 case TRUTH_ANDIF_EXPR
:
2584 case TRUTH_XOR_EXPR
:
2601 case UNORDERED_EXPR
:
2614 case WIDEN_SUM_EXPR
:
2616 case POINTER_PLUS_EXPR
:
2620 case VEC_WIDEN_MULT_HI_EXPR
:
2621 case VEC_WIDEN_MULT_LO_EXPR
:
2622 case WIDEN_MULT_EXPR
:
2624 case WIDEN_MULT_PLUS_EXPR
:
2625 case WIDEN_MULT_MINUS_EXPR
:
2627 case TRUNC_DIV_EXPR
:
2629 case FLOOR_DIV_EXPR
:
2630 case ROUND_DIV_EXPR
:
2632 case EXACT_DIV_EXPR
:
2633 case TRUNC_MOD_EXPR
:
2635 case FLOOR_MOD_EXPR
:
2636 case ROUND_MOD_EXPR
:
2640 case TRUTH_NOT_EXPR
:
2642 case POSTINCREMENT_EXPR
:
2643 case POSTDECREMENT_EXPR
:
2644 case PREINCREMENT_EXPR
:
2645 case PREDECREMENT_EXPR
:
2651 case FIX_TRUNC_EXPR
:
2657 case ARRAY_RANGE_REF
:
2661 /* Special expressions. */
2667 case REDUC_MAX_EXPR
:
2668 case REDUC_MIN_EXPR
:
2669 case REDUC_PLUS_EXPR
:
2670 case VEC_LSHIFT_EXPR
:
2671 case VEC_RSHIFT_EXPR
:
2672 case VEC_UNPACK_HI_EXPR
:
2673 case VEC_UNPACK_LO_EXPR
:
2674 case VEC_UNPACK_FLOAT_HI_EXPR
:
2675 case VEC_UNPACK_FLOAT_LO_EXPR
:
2676 case VEC_PACK_TRUNC_EXPR
:
2677 case VEC_PACK_SAT_EXPR
:
2681 /* Return an arbitrarily high precedence to avoid surrounding single
2682 VAR_DECLs in ()s. */
2687 /* Return the priority of the operator OP. */
2690 op_prio (const_tree op
)
2692 enum tree_code code
;
2697 code
= TREE_CODE (op
);
2698 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
2699 return op_prio (TREE_OPERAND (op
, 0));
2701 return op_code_prio (code
);
2704 /* Return the symbol associated with operator CODE. */
2707 op_symbol_code (enum tree_code code
)
2715 case TRUTH_ORIF_EXPR
:
2718 case TRUTH_AND_EXPR
:
2719 case TRUTH_ANDIF_EXPR
:
2725 case TRUTH_XOR_EXPR
:
2735 case UNORDERED_EXPR
:
2781 case VEC_LSHIFT_EXPR
:
2784 case VEC_RSHIFT_EXPR
:
2787 case POINTER_PLUS_EXPR
:
2793 case REDUC_PLUS_EXPR
:
2796 case WIDEN_SUM_EXPR
:
2799 case WIDEN_MULT_EXPR
:
2809 case TRUTH_NOT_EXPR
:
2816 case TRUNC_DIV_EXPR
:
2823 case FLOOR_DIV_EXPR
:
2826 case ROUND_DIV_EXPR
:
2829 case EXACT_DIV_EXPR
:
2832 case TRUNC_MOD_EXPR
:
2838 case FLOOR_MOD_EXPR
:
2841 case ROUND_MOD_EXPR
:
2844 case PREDECREMENT_EXPR
:
2847 case PREINCREMENT_EXPR
:
2850 case POSTDECREMENT_EXPR
:
2853 case POSTINCREMENT_EXPR
:
2863 return "<<< ??? >>>";
2867 /* Return the symbol associated with operator OP. */
2870 op_symbol (const_tree op
)
2872 return op_symbol_code (TREE_CODE (op
));
2875 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
2876 the gimple_call_fn of a GIMPLE_CALL. */
2879 print_call_name (pretty_printer
*buffer
, tree node
, int flags
)
2883 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
2884 op0
= TREE_OPERAND (op0
, 0);
2887 switch (TREE_CODE (op0
))
2892 dump_function_name (buffer
, op0
, flags
);
2898 op0
= TREE_OPERAND (op0
, 0);
2902 pp_string (buffer
, "(");
2903 dump_generic_node (buffer
, TREE_OPERAND (op0
, 0), 0, flags
, false);
2904 pp_string (buffer
, ") ? ");
2905 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1), 0, flags
, false);
2906 pp_string (buffer
, " : ");
2907 dump_generic_node (buffer
, TREE_OPERAND (op0
, 2), 0, flags
, false);
2911 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
2912 dump_function_name (buffer
, TREE_OPERAND (op0
, 0), flags
);
2914 dump_generic_node (buffer
, op0
, 0, flags
, false);
2918 if (integer_zerop (TREE_OPERAND (op0
, 1)))
2920 op0
= TREE_OPERAND (op0
, 0);
2927 dump_generic_node (buffer
, op0
, 0, flags
, false);
2935 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2938 pretty_print_string (pretty_printer
*buffer
, const char *str
)
2948 pp_string (buffer
, "\\b");
2952 pp_string (buffer
, "\\f");
2956 pp_string (buffer
, "\\n");
2960 pp_string (buffer
, "\\r");
2964 pp_string (buffer
, "\\t");
2968 pp_string (buffer
, "\\v");
2972 pp_string (buffer
, "\\\\");
2976 pp_string (buffer
, "\\\"");
2980 pp_string (buffer
, "\\'");
2983 /* No need to handle \0; the loop terminates on \0. */
2986 pp_string (buffer
, "\\1");
2990 pp_string (buffer
, "\\2");
2994 pp_string (buffer
, "\\3");
2998 pp_string (buffer
, "\\4");
3002 pp_string (buffer
, "\\5");
3006 pp_string (buffer
, "\\6");
3010 pp_string (buffer
, "\\7");
3014 pp_character (buffer
, str
[0]);
3022 maybe_init_pretty_print (FILE *file
)
3026 pp_construct (&buffer
, /* prefix */NULL
, /* line-width */0);
3027 pp_needs_newline (&buffer
) = true;
3028 pp_translate_identifiers (&buffer
) = false;
3032 buffer
.buffer
->stream
= file
;
3036 newline_and_indent (pretty_printer
*buffer
, int spc
)
3038 pp_newline (buffer
);
3042 /* Handle a %K format for TEXT. Separate from default_tree_printer so
3043 it can also be used in front ends.
3044 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3048 percent_K_format (text_info
*text
)
3050 tree t
= va_arg (*text
->args_ptr
, tree
), block
;
3051 gcc_assert (text
->locus
!= NULL
);
3052 *text
->locus
= EXPR_LOCATION (t
);
3053 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3054 block
= TREE_BLOCK (t
);
3055 *pp_ti_abstract_origin (text
) = NULL
;
3057 && TREE_CODE (block
) == BLOCK
3058 && BLOCK_ABSTRACT_ORIGIN (block
))
3060 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3062 while (TREE_CODE (ao
) == BLOCK
3063 && BLOCK_ABSTRACT_ORIGIN (ao
)
3064 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3065 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3067 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3069 *pp_ti_abstract_origin (text
) = block
;
3072 block
= BLOCK_SUPERCONTEXT (block
);
3076 /* Print the identifier ID to PRETTY-PRINTER. */
3079 pp_base_tree_identifier (pretty_printer
*pp
, tree id
)
3081 if (pp_translate_identifiers (pp
))
3083 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
3084 pp_append_text (pp
, text
, text
+ strlen (text
));
3087 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
3088 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
3091 /* A helper function that is used to dump function information before the
3095 dump_function_header (FILE *dump_file
, tree fdecl
, int flags
)
3097 const char *dname
, *aname
;
3098 struct cgraph_node
*node
= cgraph_get_node (fdecl
);
3099 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
3101 dname
= lang_hooks
.decl_printable_name (fdecl
, 2);
3103 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
3104 aname
= (IDENTIFIER_POINTER
3105 (DECL_ASSEMBLER_NAME (fdecl
)));
3107 aname
= "<unset-asm-name>";
3109 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
3110 dname
, aname
, fun
->funcdef_no
);
3111 if (!(flags
& TDF_NOUID
))
3112 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
3115 fprintf (dump_file
, ", cgraph_uid=%d)%s\n\n", node
->uid
,
3116 node
->frequency
== NODE_FREQUENCY_HOT
3118 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
3119 ? " (unlikely executed)"
3120 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
3121 ? " (executed once)"
3125 fprintf (dump_file
, ")\n\n");