1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
3 2011, 2012 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"
27 #include "tree-pretty-print.h"
29 #include "tree-flow.h"
30 #include "langhooks.h"
31 #include "tree-iterator.h"
32 #include "tree-chrec.h"
34 #include "value-prof.h"
37 /* Local functions, macros and variables. */
38 static const char *op_symbol (const_tree
);
39 static void pretty_print_string (pretty_printer
*, const char*);
40 static void newline_and_indent (pretty_printer
*, int);
41 static void maybe_init_pretty_print (FILE *);
42 static void print_struct_decl (pretty_printer
*, const_tree
, int, int);
43 static void do_niy (pretty_printer
*, const_tree
);
45 #define INDENT(SPACE) do { \
46 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
48 #define NIY do_niy(buffer,node)
50 static pretty_printer buffer
;
51 static int initialized
= 0;
53 /* Try to print something for an unknown tree code. */
56 do_niy (pretty_printer
*buffer
, const_tree node
)
60 pp_string (buffer
, "<<< Unknown tree: ");
61 pp_string (buffer
, tree_code_name
[(int) TREE_CODE (node
)]);
65 len
= TREE_OPERAND_LENGTH (node
);
66 for (i
= 0; i
< len
; ++i
)
68 newline_and_indent (buffer
, 2);
69 dump_generic_node (buffer
, TREE_OPERAND (node
, i
), 2, 0, false);
73 pp_string (buffer
, " >>>");
76 /* Debugging function to print out a generic expression. */
79 debug_generic_expr (tree t
)
81 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
82 fprintf (stderr
, "\n");
85 /* Debugging function to print out a generic statement. */
88 debug_generic_stmt (tree t
)
90 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
91 fprintf (stderr
, "\n");
94 /* Debugging function to print out a chain of trees . */
97 debug_tree_chain (tree t
)
99 struct pointer_set_t
*seen
= pointer_set_create ();
103 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
104 fprintf (stderr
, " ");
106 if (pointer_set_insert (seen
, t
))
108 fprintf (stderr
, "... [cycled back to ");
109 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
110 fprintf (stderr
, "]");
114 fprintf (stderr
, "\n");
116 pointer_set_destroy (seen
);
119 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
121 print_generic_decl (FILE *file
, tree decl
, int flags
)
123 maybe_init_pretty_print (file
);
124 print_declaration (&buffer
, decl
, 2, flags
);
125 pp_write_text_to_stream (&buffer
);
128 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
129 to show in the dump. See TDF_* in dumpfile.h. */
132 print_generic_stmt (FILE *file
, tree t
, int flags
)
134 maybe_init_pretty_print (file
);
135 dump_generic_node (&buffer
, t
, 0, flags
, true);
136 pp_newline_and_flush (&buffer
);
139 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
140 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
144 print_generic_stmt_indented (FILE *file
, tree t
, int flags
, int indent
)
148 maybe_init_pretty_print (file
);
150 for (i
= 0; i
< indent
; i
++)
152 dump_generic_node (&buffer
, t
, indent
, flags
, true);
153 pp_newline_and_flush (&buffer
);
156 /* Print a single expression T on file FILE. FLAGS specifies details to show
157 in the dump. See TDF_* in dumpfile.h. */
160 print_generic_expr (FILE *file
, tree t
, int flags
)
162 maybe_init_pretty_print (file
);
163 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_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
553 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
555 pp_string (buffer
, "NONLOCALIZED_VARS: ");
556 FOR_EACH_VEC_ELT (*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 dumpfile.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
,
608 if (node
== NULL_TREE
)
611 is_expr
= EXPR_P (node
);
613 if (is_stmt
&& (flags
& TDF_STMTADDR
))
614 pp_printf (buffer
, "<&%p> ", (void *)node
);
616 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
617 dump_location (buffer
, EXPR_LOCATION (node
));
619 code
= TREE_CODE (node
);
623 pp_string (buffer
, "<<< error >>>");
626 case IDENTIFIER_NODE
:
627 pp_tree_identifier (buffer
, node
);
631 while (node
&& node
!= error_mark_node
)
633 if (TREE_PURPOSE (node
))
635 dump_generic_node (buffer
, TREE_PURPOSE (node
), spc
, flags
, false);
638 dump_generic_node (buffer
, TREE_VALUE (node
), spc
, flags
, false);
639 node
= TREE_CHAIN (node
);
640 if (node
&& TREE_CODE (node
) == TREE_LIST
)
642 pp_character (buffer
, ',');
649 dump_generic_node (buffer
, BINFO_TYPE (node
), spc
, flags
, false);
655 if (TREE_VEC_LENGTH (node
) > 0)
657 size_t len
= TREE_VEC_LENGTH (node
);
658 for (i
= 0; i
< len
- 1; i
++)
660 dump_generic_node (buffer
, TREE_VEC_ELT (node
, i
), spc
, flags
,
662 pp_character (buffer
, ',');
665 dump_generic_node (buffer
, TREE_VEC_ELT (node
, len
- 1), spc
,
674 case FIXED_POINT_TYPE
:
680 unsigned int quals
= TYPE_QUALS (node
);
681 enum tree_code_class tclass
;
683 if (quals
& TYPE_QUAL_CONST
)
684 pp_string (buffer
, "const ");
685 else if (quals
& TYPE_QUAL_VOLATILE
)
686 pp_string (buffer
, "volatile ");
687 else if (quals
& TYPE_QUAL_RESTRICT
)
688 pp_string (buffer
, "restrict ");
690 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
692 pp_string (buffer
, "<address-space-");
693 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
694 pp_string (buffer
, "> ");
697 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
699 if (tclass
== tcc_declaration
)
701 if (DECL_NAME (node
))
702 dump_decl_name (buffer
, node
, flags
);
704 pp_string (buffer
, "<unnamed type decl>");
706 else if (tclass
== tcc_type
)
708 if (TYPE_NAME (node
))
710 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
711 pp_tree_identifier (buffer
, TYPE_NAME (node
));
712 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
713 && DECL_NAME (TYPE_NAME (node
)))
714 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
716 pp_string (buffer
, "<unnamed type>");
718 else if (TREE_CODE (node
) == VECTOR_TYPE
)
720 pp_string (buffer
, "vector");
721 pp_character (buffer
, '(');
722 pp_wide_integer (buffer
, TYPE_VECTOR_SUBPARTS (node
));
723 pp_string (buffer
, ") ");
724 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
726 else if (TREE_CODE (node
) == INTEGER_TYPE
)
728 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
729 pp_string (buffer
, (TYPE_UNSIGNED (node
)
732 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
733 pp_string (buffer
, (TYPE_UNSIGNED (node
)
736 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
737 pp_string (buffer
, (TYPE_UNSIGNED (node
)
740 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
741 pp_string (buffer
, (TYPE_UNSIGNED (node
)
744 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
745 pp_string (buffer
, (TYPE_UNSIGNED (node
)
746 ? "unsigned long long"
747 : "signed long long"));
748 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
749 && exact_log2 (TYPE_PRECISION (node
)) != -1)
751 pp_string (buffer
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
752 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
753 pp_string (buffer
, "_t");
757 pp_string (buffer
, (TYPE_UNSIGNED (node
)
758 ? "<unnamed-unsigned:"
759 : "<unnamed-signed:"));
760 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
761 pp_string (buffer
, ">");
764 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
766 pp_string (buffer
, "__complex__ ");
767 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
769 else if (TREE_CODE (node
) == REAL_TYPE
)
771 pp_string (buffer
, "<float:");
772 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
773 pp_string (buffer
, ">");
775 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
777 pp_string (buffer
, "<fixed-point-");
778 pp_string (buffer
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
779 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
780 pp_string (buffer
, ">");
782 else if (TREE_CODE (node
) == VOID_TYPE
)
783 pp_string (buffer
, "void");
785 pp_string (buffer
, "<unnamed type>");
792 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
794 if (TREE_TYPE (node
) == NULL
)
796 pp_string (buffer
, str
);
797 pp_string (buffer
, "<null type>");
799 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
801 tree fnode
= TREE_TYPE (node
);
803 dump_generic_node (buffer
, TREE_TYPE (fnode
), spc
, flags
, false);
805 pp_character (buffer
, '(');
806 pp_string (buffer
, str
);
807 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
808 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
809 else if (flags
& TDF_NOUID
)
810 pp_printf (buffer
, "<Txxxx>");
812 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
814 pp_character (buffer
, ')');
815 dump_function_declaration (buffer
, fnode
, spc
, flags
);
819 unsigned int quals
= TYPE_QUALS (node
);
821 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
823 pp_string (buffer
, str
);
825 if (quals
& TYPE_QUAL_CONST
)
826 pp_string (buffer
, " const");
827 if (quals
& TYPE_QUAL_VOLATILE
)
828 pp_string (buffer
, " volatile");
829 if (quals
& TYPE_QUAL_RESTRICT
)
830 pp_string (buffer
, " restrict");
832 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
834 pp_string (buffer
, " <address-space-");
835 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
836 pp_string (buffer
, ">");
839 if (TYPE_REF_CAN_ALIAS_ALL (node
))
840 pp_string (buffer
, " {ref-all}");
850 if (integer_zerop (TREE_OPERAND (node
, 1))
851 /* Dump the types of INTEGER_CSTs explicitly, for we can't
852 infer them and MEM_ATTR caching will share MEM_REFs
853 with differently-typed op0s. */
854 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
855 /* Released SSA_NAMES have no TREE_TYPE. */
856 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
857 /* Same pointer types, but ignoring POINTER_TYPE vs.
859 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
860 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
861 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
862 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
863 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
864 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
865 /* Same value types ignoring qualifiers. */
866 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
868 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))))
870 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
872 pp_string (buffer
, "*");
873 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
877 dump_generic_node (buffer
,
878 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
885 pp_string (buffer
, "MEM[");
886 pp_string (buffer
, "(");
887 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
888 dump_generic_node (buffer
, ptype
,
889 spc
, flags
| TDF_SLIM
, false);
890 pp_string (buffer
, ")");
891 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
893 if (!integer_zerop (TREE_OPERAND (node
, 1)))
895 pp_string (buffer
, " + ");
896 dump_generic_node (buffer
, TREE_OPERAND (node
, 1),
899 pp_string (buffer
, "]");
906 const char *sep
= "";
909 pp_string (buffer
, "MEM[");
911 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
913 pp_string (buffer
, sep
);
915 pp_string (buffer
, "symbol: ");
916 dump_generic_node (buffer
, TREE_OPERAND (TMR_BASE (node
), 0),
921 pp_string (buffer
, sep
);
923 pp_string (buffer
, "base: ");
924 dump_generic_node (buffer
, TMR_BASE (node
), spc
, flags
, false);
926 tmp
= TMR_INDEX2 (node
);
929 pp_string (buffer
, sep
);
931 pp_string (buffer
, "base: ");
932 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
934 tmp
= TMR_INDEX (node
);
937 pp_string (buffer
, sep
);
939 pp_string (buffer
, "index: ");
940 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
942 tmp
= TMR_STEP (node
);
945 pp_string (buffer
, sep
);
947 pp_string (buffer
, "step: ");
948 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
950 tmp
= TMR_OFFSET (node
);
953 pp_string (buffer
, sep
);
955 pp_string (buffer
, "offset: ");
956 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
958 pp_string (buffer
, "]");
966 /* Print the innermost component type. */
967 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
968 tmp
= TREE_TYPE (tmp
))
970 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
972 /* Print the dimensions. */
973 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
974 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
980 case QUAL_UNION_TYPE
:
982 unsigned int quals
= TYPE_QUALS (node
);
984 if (quals
& TYPE_QUAL_CONST
)
985 pp_string (buffer
, "const ");
986 if (quals
& TYPE_QUAL_VOLATILE
)
987 pp_string (buffer
, "volatile ");
989 /* Print the name of the structure. */
990 if (TREE_CODE (node
) == RECORD_TYPE
)
991 pp_string (buffer
, "struct ");
992 else if (TREE_CODE (node
) == UNION_TYPE
)
993 pp_string (buffer
, "union ");
995 if (TYPE_NAME (node
))
996 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, flags
, false);
997 else if (!(flags
& TDF_SLIM
))
998 /* FIXME: If we eliminate the 'else' above and attempt
999 to show the fields for named types, we may get stuck
1000 following a cycle of pointers to structs. The alleged
1001 self-reference check in print_struct_decl will not detect
1002 cycles involving more than one pointer or struct type. */
1003 print_struct_decl (buffer
, node
, spc
, flags
);
1012 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
1014 /* In the case of a pointer, one may want to divide by the
1015 size of the pointed-to type. Unfortunately, this not
1016 straightforward. The C front-end maps expressions
1021 in such a way that the two INTEGER_CST nodes for "5" have
1022 different values but identical types. In the latter
1023 case, the 5 is multiplied by sizeof (int) in c-common.c
1024 (pointer_int_sum) to convert it to a byte address, and
1025 yet the type of the node is left unchanged. Argh. What
1026 is consistent though is that the number value corresponds
1027 to bytes (UNITS) offset.
1029 NB: Neither of the following divisors can be trivially
1030 used to recover the original literal:
1032 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1033 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1034 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
1035 pp_string (buffer
, "B"); /* pseudo-unit */
1037 else if (host_integerp (node
, 0))
1038 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
1039 else if (host_integerp (node
, 1))
1040 pp_unsigned_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
1044 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (val
);
1045 HOST_WIDE_INT high
= TREE_INT_CST_HIGH (val
);
1047 if (tree_int_cst_sgn (val
) < 0)
1049 pp_character (buffer
, '-');
1050 high
= ~high
+ !low
;
1053 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
1055 sprintf (pp_buffer (buffer
)->digit_buffer
,
1056 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
1057 (unsigned HOST_WIDE_INT
) high
, low
);
1058 pp_string (buffer
, pp_buffer (buffer
)->digit_buffer
);
1063 /* Code copied from print_node. */
1066 if (TREE_OVERFLOW (node
))
1067 pp_string (buffer
, " overflow");
1069 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
1070 d
= TREE_REAL_CST (node
);
1071 if (REAL_VALUE_ISINF (d
))
1072 pp_string (buffer
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1073 else if (REAL_VALUE_ISNAN (d
))
1074 pp_string (buffer
, " Nan");
1078 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1079 pp_string (buffer
, string
);
1084 unsigned char *p
= (unsigned char *) &TREE_REAL_CST (node
);
1085 pp_string (buffer
, "0x");
1086 for (i
= 0; i
< sizeof TREE_REAL_CST (node
); i
++)
1087 output_formatted_integer (buffer
, "%02x", *p
++);
1096 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1097 pp_string (buffer
, string
);
1102 pp_string (buffer
, "__complex__ (");
1103 dump_generic_node (buffer
, TREE_REALPART (node
), spc
, flags
, false);
1104 pp_string (buffer
, ", ");
1105 dump_generic_node (buffer
, TREE_IMAGPART (node
), spc
, flags
, false);
1106 pp_string (buffer
, ")");
1110 pp_string (buffer
, "\"");
1111 pretty_print_string (buffer
, TREE_STRING_POINTER (node
));
1112 pp_string (buffer
, "\"");
1118 pp_string (buffer
, "{ ");
1119 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1122 pp_string (buffer
, ", ");
1123 dump_generic_node (buffer
, VECTOR_CST_ELT (node
, i
),
1126 pp_string (buffer
, " }");
1132 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1134 if (TREE_CODE (node
) == METHOD_TYPE
)
1136 if (TYPE_METHOD_BASETYPE (node
))
1137 dump_decl_name (buffer
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1140 pp_string (buffer
, "<null method basetype>");
1141 pp_string (buffer
, "::");
1143 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1144 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
1145 else if (flags
& TDF_NOUID
)
1146 pp_printf (buffer
, "<Txxxx>");
1148 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
1149 dump_function_declaration (buffer
, node
, spc
, flags
);
1154 dump_decl_name (buffer
, node
, flags
);
1158 if (DECL_NAME (node
))
1159 dump_decl_name (buffer
, node
, flags
);
1160 else if (LABEL_DECL_UID (node
) != -1)
1161 pp_printf (buffer
, "<L%d>", (int) LABEL_DECL_UID (node
));
1164 if (flags
& TDF_NOUID
)
1165 pp_string (buffer
, "<D.xxxx>");
1167 pp_printf (buffer
, "<D.%u>", DECL_UID (node
));
1172 if (DECL_IS_BUILTIN (node
))
1174 /* Don't print the declaration of built-in types. */
1177 if (DECL_NAME (node
))
1178 dump_decl_name (buffer
, node
, flags
);
1179 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1181 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1182 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1183 && TYPE_METHODS (TREE_TYPE (node
)))
1185 /* The type is a c++ class: all structures have at least
1187 pp_string (buffer
, "class ");
1188 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1193 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1194 ? "union" : "struct "));
1195 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1199 pp_string (buffer
, "<anon>");
1205 case DEBUG_EXPR_DECL
:
1206 case NAMESPACE_DECL
:
1207 dump_decl_name (buffer
, node
, flags
);
1211 pp_string (buffer
, "<retval>");
1215 op0
= TREE_OPERAND (node
, 0);
1218 && (TREE_CODE (op0
) == INDIRECT_REF
1219 || (TREE_CODE (op0
) == MEM_REF
1220 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1221 && integer_zerop (TREE_OPERAND (op0
, 1))
1222 /* Dump the types of INTEGER_CSTs explicitly, for we
1223 can't infer them and MEM_ATTR caching will share
1224 MEM_REFs with differently-typed op0s. */
1225 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1226 /* Released SSA_NAMES have no TREE_TYPE. */
1227 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1228 /* Same pointer types, but ignoring POINTER_TYPE vs.
1230 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1231 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1232 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1233 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1234 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1235 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1236 /* Same value types ignoring qualifiers. */
1237 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1238 == TYPE_MAIN_VARIANT
1239 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))))))
1241 op0
= TREE_OPERAND (op0
, 0);
1244 if (op_prio (op0
) < op_prio (node
))
1245 pp_character (buffer
, '(');
1246 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1247 if (op_prio (op0
) < op_prio (node
))
1248 pp_character (buffer
, ')');
1249 pp_string (buffer
, str
);
1250 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1251 op0
= component_ref_field_offset (node
);
1252 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1254 pp_string (buffer
, "{off: ");
1255 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1256 pp_character (buffer
, '}');
1261 pp_string (buffer
, "BIT_FIELD_REF <");
1262 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1263 pp_string (buffer
, ", ");
1264 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1265 pp_string (buffer
, ", ");
1266 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1267 pp_string (buffer
, ">");
1271 case ARRAY_RANGE_REF
:
1272 op0
= TREE_OPERAND (node
, 0);
1273 if (op_prio (op0
) < op_prio (node
))
1274 pp_character (buffer
, '(');
1275 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1276 if (op_prio (op0
) < op_prio (node
))
1277 pp_character (buffer
, ')');
1278 pp_character (buffer
, '[');
1279 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1280 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1281 pp_string (buffer
, " ...");
1282 pp_character (buffer
, ']');
1284 op0
= array_ref_low_bound (node
);
1285 op1
= array_ref_element_size (node
);
1287 if (!integer_zerop (op0
)
1288 || TREE_OPERAND (node
, 2)
1289 || TREE_OPERAND (node
, 3))
1291 pp_string (buffer
, "{lb: ");
1292 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1293 pp_string (buffer
, " sz: ");
1294 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1295 pp_character (buffer
, '}');
1301 unsigned HOST_WIDE_INT ix
;
1303 bool is_struct_init
= false;
1304 bool is_array_init
= false;
1305 double_int curidx
= double_int_zero
;
1306 pp_character (buffer
, '{');
1307 if (TREE_CLOBBER_P (node
))
1308 pp_string (buffer
, "CLOBBER");
1309 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1310 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1311 is_struct_init
= true;
1312 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
1313 && TYPE_DOMAIN (TREE_TYPE (node
))
1314 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
1315 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
1318 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
1319 is_array_init
= true;
1320 curidx
= tree_to_double_int (minv
);
1322 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1328 pp_character (buffer
, '.');
1329 dump_generic_node (buffer
, field
, spc
, flags
, false);
1330 pp_character (buffer
, '=');
1332 else if (is_array_init
1333 && (TREE_CODE (field
) != INTEGER_CST
1334 || tree_to_double_int (field
) != curidx
))
1336 pp_character (buffer
, '[');
1337 if (TREE_CODE (field
) == RANGE_EXPR
)
1339 dump_generic_node (buffer
, TREE_OPERAND (field
, 0), spc
,
1341 pp_string (buffer
, " ... ");
1342 dump_generic_node (buffer
, TREE_OPERAND (field
, 1), spc
,
1344 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
1345 curidx
= tree_to_double_int (TREE_OPERAND (field
, 1));
1348 dump_generic_node (buffer
, field
, spc
, flags
, false);
1349 if (TREE_CODE (field
) == INTEGER_CST
)
1350 curidx
= tree_to_double_int (field
);
1351 pp_string (buffer
, "]=");
1355 curidx
+= double_int_one
;
1356 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1357 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1358 val
= TREE_OPERAND (val
, 0);
1359 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1360 dump_decl_name (buffer
, val
, flags
);
1362 dump_generic_node (buffer
, val
, spc
, flags
, false);
1363 if (ix
!= vec_safe_length (CONSTRUCTOR_ELTS (node
)) - 1)
1365 pp_character (buffer
, ',');
1369 pp_character (buffer
, '}');
1376 if (flags
& TDF_SLIM
)
1378 pp_string (buffer
, "<COMPOUND_EXPR>");
1382 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1383 spc
, flags
, !(flags
& TDF_SLIM
));
1384 if (flags
& TDF_SLIM
)
1385 newline_and_indent (buffer
, spc
);
1388 pp_character (buffer
, ',');
1392 for (tp
= &TREE_OPERAND (node
, 1);
1393 TREE_CODE (*tp
) == COMPOUND_EXPR
;
1394 tp
= &TREE_OPERAND (*tp
, 1))
1396 dump_generic_node (buffer
, TREE_OPERAND (*tp
, 0),
1397 spc
, flags
, !(flags
& TDF_SLIM
));
1398 if (flags
& TDF_SLIM
)
1399 newline_and_indent (buffer
, spc
);
1402 pp_character (buffer
, ',');
1407 dump_generic_node (buffer
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
1411 case STATEMENT_LIST
:
1413 tree_stmt_iterator si
;
1416 if (flags
& TDF_SLIM
)
1418 pp_string (buffer
, "<STATEMENT_LIST>");
1422 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
1425 newline_and_indent (buffer
, spc
);
1428 dump_generic_node (buffer
, tsi_stmt (si
), spc
, flags
, true);
1435 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
,
1438 pp_character (buffer
, '=');
1440 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
,
1445 pp_string (buffer
, "TARGET_EXPR <");
1446 dump_generic_node (buffer
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
1447 pp_character (buffer
, ',');
1449 dump_generic_node (buffer
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
1450 pp_character (buffer
, '>');
1454 print_declaration (buffer
, DECL_EXPR_DECL (node
), spc
, flags
);
1459 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
1461 pp_string (buffer
, "if (");
1462 dump_generic_node (buffer
, COND_EXPR_COND (node
), spc
, flags
, false);
1463 pp_character (buffer
, ')');
1464 /* The lowered cond_exprs should always be printed in full. */
1465 if (COND_EXPR_THEN (node
)
1466 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
1467 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
1468 && COND_EXPR_ELSE (node
)
1469 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
1470 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
1473 dump_generic_node (buffer
, COND_EXPR_THEN (node
),
1475 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1477 pp_string (buffer
, " else ");
1478 dump_generic_node (buffer
, COND_EXPR_ELSE (node
),
1482 else if (!(flags
& TDF_SLIM
))
1484 /* Output COND_EXPR_THEN. */
1485 if (COND_EXPR_THEN (node
))
1487 newline_and_indent (buffer
, spc
+2);
1488 pp_character (buffer
, '{');
1489 newline_and_indent (buffer
, spc
+4);
1490 dump_generic_node (buffer
, COND_EXPR_THEN (node
), spc
+4,
1492 newline_and_indent (buffer
, spc
+2);
1493 pp_character (buffer
, '}');
1496 /* Output COND_EXPR_ELSE. */
1497 if (COND_EXPR_ELSE (node
)
1498 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1500 newline_and_indent (buffer
, spc
);
1501 pp_string (buffer
, "else");
1502 newline_and_indent (buffer
, spc
+2);
1503 pp_character (buffer
, '{');
1504 newline_and_indent (buffer
, spc
+4);
1505 dump_generic_node (buffer
, COND_EXPR_ELSE (node
), spc
+4,
1507 newline_and_indent (buffer
, spc
+2);
1508 pp_character (buffer
, '}');
1515 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1517 pp_character (buffer
, '?');
1519 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1521 pp_character (buffer
, ':');
1523 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1528 pp_character (buffer
, '{');
1529 if (!(flags
& TDF_SLIM
))
1531 if (BIND_EXPR_VARS (node
))
1533 pp_newline (buffer
);
1535 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
1537 print_declaration (buffer
, op0
, spc
+2, flags
);
1538 pp_newline (buffer
);
1542 newline_and_indent (buffer
, spc
+2);
1543 dump_generic_node (buffer
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
1544 newline_and_indent (buffer
, spc
);
1545 pp_character (buffer
, '}');
1551 print_call_name (buffer
, CALL_EXPR_FN (node
), flags
);
1553 /* Print parameters. */
1555 pp_character (buffer
, '(');
1558 call_expr_arg_iterator iter
;
1559 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
1561 dump_generic_node (buffer
, arg
, spc
, flags
, false);
1562 if (more_call_expr_args_p (&iter
))
1564 pp_character (buffer
, ',');
1569 if (CALL_EXPR_VA_ARG_PACK (node
))
1571 if (call_expr_nargs (node
) > 0)
1573 pp_character (buffer
, ',');
1576 pp_string (buffer
, "__builtin_va_arg_pack ()");
1578 pp_character (buffer
, ')');
1580 op1
= CALL_EXPR_STATIC_CHAIN (node
);
1583 pp_string (buffer
, " [static-chain: ");
1584 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1585 pp_character (buffer
, ']');
1588 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
1589 pp_string (buffer
, " [return slot optimization]");
1590 if (CALL_EXPR_TAILCALL (node
))
1591 pp_string (buffer
, " [tail call]");
1594 case WITH_CLEANUP_EXPR
:
1598 case CLEANUP_POINT_EXPR
:
1599 pp_string (buffer
, "<<cleanup_point ");
1600 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1601 pp_string (buffer
, ">>");
1604 case PLACEHOLDER_EXPR
:
1605 pp_string (buffer
, "<PLACEHOLDER_EXPR ");
1606 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1607 pp_character (buffer
, '>');
1610 /* Binary arithmetic and logic expressions. */
1611 case WIDEN_SUM_EXPR
:
1612 case WIDEN_MULT_EXPR
:
1614 case MULT_HIGHPART_EXPR
:
1616 case POINTER_PLUS_EXPR
:
1618 case TRUNC_DIV_EXPR
:
1620 case FLOOR_DIV_EXPR
:
1621 case ROUND_DIV_EXPR
:
1622 case TRUNC_MOD_EXPR
:
1624 case FLOOR_MOD_EXPR
:
1625 case ROUND_MOD_EXPR
:
1627 case EXACT_DIV_EXPR
:
1632 case VEC_LSHIFT_EXPR
:
1633 case VEC_RSHIFT_EXPR
:
1634 case WIDEN_LSHIFT_EXPR
:
1638 case TRUTH_ANDIF_EXPR
:
1639 case TRUTH_ORIF_EXPR
:
1640 case TRUTH_AND_EXPR
:
1642 case TRUTH_XOR_EXPR
:
1656 case UNORDERED_EXPR
:
1658 const char *op
= op_symbol (node
);
1659 op0
= TREE_OPERAND (node
, 0);
1660 op1
= TREE_OPERAND (node
, 1);
1662 /* When the operands are expressions with less priority,
1663 keep semantics of the tree representation. */
1664 if (op_prio (op0
) <= op_prio (node
))
1666 pp_character (buffer
, '(');
1667 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1668 pp_character (buffer
, ')');
1671 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1674 pp_string (buffer
, op
);
1677 /* When the operands are expressions with less priority,
1678 keep semantics of the tree representation. */
1679 if (op_prio (op1
) <= op_prio (node
))
1681 pp_character (buffer
, '(');
1682 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1683 pp_character (buffer
, ')');
1686 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1690 /* Unary arithmetic and logic expressions. */
1693 case TRUTH_NOT_EXPR
:
1695 case PREDECREMENT_EXPR
:
1696 case PREINCREMENT_EXPR
:
1698 if (TREE_CODE (node
) == ADDR_EXPR
1699 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
1700 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
1701 ; /* Do not output '&' for strings and function pointers. */
1703 pp_string (buffer
, op_symbol (node
));
1705 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1707 pp_character (buffer
, '(');
1708 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1709 pp_character (buffer
, ')');
1712 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1715 case POSTDECREMENT_EXPR
:
1716 case POSTINCREMENT_EXPR
:
1717 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1719 pp_character (buffer
, '(');
1720 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1721 pp_character (buffer
, ')');
1724 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1725 pp_string (buffer
, op_symbol (node
));
1729 pp_string (buffer
, "MIN_EXPR <");
1730 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1731 pp_string (buffer
, ", ");
1732 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1733 pp_character (buffer
, '>');
1737 pp_string (buffer
, "MAX_EXPR <");
1738 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1739 pp_string (buffer
, ", ");
1740 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1741 pp_character (buffer
, '>');
1745 pp_string (buffer
, "ABS_EXPR <");
1746 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1747 pp_character (buffer
, '>');
1754 case ADDR_SPACE_CONVERT_EXPR
:
1755 case FIXED_CONVERT_EXPR
:
1756 case FIX_TRUNC_EXPR
:
1759 type
= TREE_TYPE (node
);
1760 op0
= TREE_OPERAND (node
, 0);
1761 if (type
!= TREE_TYPE (op0
))
1763 pp_character (buffer
, '(');
1764 dump_generic_node (buffer
, type
, spc
, flags
, false);
1765 pp_string (buffer
, ") ");
1767 if (op_prio (op0
) < op_prio (node
))
1768 pp_character (buffer
, '(');
1769 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1770 if (op_prio (op0
) < op_prio (node
))
1771 pp_character (buffer
, ')');
1774 case VIEW_CONVERT_EXPR
:
1775 pp_string (buffer
, "VIEW_CONVERT_EXPR<");
1776 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1777 pp_string (buffer
, ">(");
1778 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1779 pp_character (buffer
, ')');
1783 pp_string (buffer
, "((");
1784 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1785 pp_string (buffer
, "))");
1788 case NON_LVALUE_EXPR
:
1789 pp_string (buffer
, "NON_LVALUE_EXPR <");
1790 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1791 pp_character (buffer
, '>');
1795 pp_string (buffer
, "SAVE_EXPR <");
1796 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1797 pp_character (buffer
, '>');
1801 pp_string (buffer
, "COMPLEX_EXPR <");
1802 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1803 pp_string (buffer
, ", ");
1804 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1805 pp_string (buffer
, ">");
1809 pp_string (buffer
, "CONJ_EXPR <");
1810 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1811 pp_string (buffer
, ">");
1815 pp_string (buffer
, "REALPART_EXPR <");
1816 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1817 pp_string (buffer
, ">");
1821 pp_string (buffer
, "IMAGPART_EXPR <");
1822 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1823 pp_string (buffer
, ">");
1827 pp_string (buffer
, "VA_ARG_EXPR <");
1828 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1829 pp_string (buffer
, ">");
1832 case TRY_FINALLY_EXPR
:
1833 case TRY_CATCH_EXPR
:
1834 pp_string (buffer
, "try");
1835 newline_and_indent (buffer
, spc
+2);
1836 pp_string (buffer
, "{");
1837 newline_and_indent (buffer
, spc
+4);
1838 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
1839 newline_and_indent (buffer
, spc
+2);
1840 pp_string (buffer
, "}");
1841 newline_and_indent (buffer
, spc
);
1843 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
1844 newline_and_indent (buffer
, spc
+2);
1845 pp_string (buffer
, "{");
1846 newline_and_indent (buffer
, spc
+4);
1847 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
1848 newline_and_indent (buffer
, spc
+2);
1849 pp_string (buffer
, "}");
1854 pp_string (buffer
, "catch (");
1855 dump_generic_node (buffer
, CATCH_TYPES (node
), spc
+2, flags
, false);
1856 pp_string (buffer
, ")");
1857 newline_and_indent (buffer
, spc
+2);
1858 pp_string (buffer
, "{");
1859 newline_and_indent (buffer
, spc
+4);
1860 dump_generic_node (buffer
, CATCH_BODY (node
), spc
+4, flags
, true);
1861 newline_and_indent (buffer
, spc
+2);
1862 pp_string (buffer
, "}");
1866 case EH_FILTER_EXPR
:
1867 pp_string (buffer
, "<<<eh_filter (");
1868 dump_generic_node (buffer
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
1869 pp_string (buffer
, ")>>>");
1870 newline_and_indent (buffer
, spc
+2);
1871 pp_string (buffer
, "{");
1872 newline_and_indent (buffer
, spc
+4);
1873 dump_generic_node (buffer
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
1874 newline_and_indent (buffer
, spc
+2);
1875 pp_string (buffer
, "}");
1880 op0
= TREE_OPERAND (node
, 0);
1881 /* If this is for break or continue, don't bother printing it. */
1882 if (DECL_NAME (op0
))
1884 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
1885 if (strcmp (name
, "break") == 0
1886 || strcmp (name
, "continue") == 0)
1889 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1890 pp_character (buffer
, ':');
1891 if (DECL_NONLOCAL (op0
))
1892 pp_string (buffer
, " [non-local]");
1896 pp_string (buffer
, "while (1)");
1897 if (!(flags
& TDF_SLIM
))
1899 newline_and_indent (buffer
, spc
+2);
1900 pp_character (buffer
, '{');
1901 newline_and_indent (buffer
, spc
+4);
1902 dump_generic_node (buffer
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
1903 newline_and_indent (buffer
, spc
+2);
1904 pp_character (buffer
, '}');
1910 pp_string (buffer
, "// predicted ");
1911 if (PREDICT_EXPR_OUTCOME (node
))
1912 pp_string (buffer
, "likely by ");
1914 pp_string (buffer
, "unlikely by ");
1915 pp_string (buffer
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
1916 pp_string (buffer
, " predictor.");
1920 pp_string (buffer
, "return");
1921 op0
= TREE_OPERAND (node
, 0);
1925 if (TREE_CODE (op0
) == MODIFY_EXPR
)
1926 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1),
1929 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1934 pp_string (buffer
, "if (");
1935 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1936 pp_string (buffer
, ") break");
1940 pp_string (buffer
, "switch (");
1941 dump_generic_node (buffer
, SWITCH_COND (node
), spc
, flags
, false);
1942 pp_character (buffer
, ')');
1943 if (!(flags
& TDF_SLIM
))
1945 newline_and_indent (buffer
, spc
+2);
1946 pp_character (buffer
, '{');
1947 if (SWITCH_BODY (node
))
1949 newline_and_indent (buffer
, spc
+4);
1950 dump_generic_node (buffer
, SWITCH_BODY (node
), spc
+4, flags
,
1955 tree vec
= SWITCH_LABELS (node
);
1956 size_t i
, n
= TREE_VEC_LENGTH (vec
);
1957 for (i
= 0; i
< n
; ++i
)
1959 tree elt
= TREE_VEC_ELT (vec
, i
);
1960 newline_and_indent (buffer
, spc
+4);
1963 dump_generic_node (buffer
, elt
, spc
+4, flags
, false);
1964 pp_string (buffer
, " goto ");
1965 dump_generic_node (buffer
, CASE_LABEL (elt
), spc
+4,
1967 pp_semicolon (buffer
);
1970 pp_string (buffer
, "case ???: goto ???;");
1973 newline_and_indent (buffer
, spc
+2);
1974 pp_character (buffer
, '}');
1980 op0
= GOTO_DESTINATION (node
);
1981 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
1983 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
1984 if (strcmp (name
, "break") == 0
1985 || strcmp (name
, "continue") == 0)
1987 pp_string (buffer
, name
);
1991 pp_string (buffer
, "goto ");
1992 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1996 pp_string (buffer
, "__asm__");
1997 if (ASM_VOLATILE_P (node
))
1998 pp_string (buffer
, " __volatile__");
1999 pp_character (buffer
, '(');
2000 dump_generic_node (buffer
, ASM_STRING (node
), spc
, flags
, false);
2001 pp_character (buffer
, ':');
2002 dump_generic_node (buffer
, ASM_OUTPUTS (node
), spc
, flags
, false);
2003 pp_character (buffer
, ':');
2004 dump_generic_node (buffer
, ASM_INPUTS (node
), spc
, flags
, false);
2005 if (ASM_CLOBBERS (node
))
2007 pp_character (buffer
, ':');
2008 dump_generic_node (buffer
, ASM_CLOBBERS (node
), spc
, flags
, false);
2010 pp_string (buffer
, ")");
2013 case CASE_LABEL_EXPR
:
2014 if (CASE_LOW (node
) && CASE_HIGH (node
))
2016 pp_string (buffer
, "case ");
2017 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
2018 pp_string (buffer
, " ... ");
2019 dump_generic_node (buffer
, CASE_HIGH (node
), spc
, flags
, false);
2021 else if (CASE_LOW (node
))
2023 pp_string (buffer
, "case ");
2024 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
2027 pp_string (buffer
, "default");
2028 pp_character (buffer
, ':');
2032 pp_string (buffer
, "OBJ_TYPE_REF(");
2033 dump_generic_node (buffer
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2034 pp_character (buffer
, ';');
2035 dump_generic_node (buffer
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2036 pp_character (buffer
, '-');
2037 pp_character (buffer
, '>');
2038 dump_generic_node (buffer
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2039 pp_character (buffer
, ')');
2043 if (SSA_NAME_IDENTIFIER (node
))
2044 dump_generic_node (buffer
, SSA_NAME_IDENTIFIER (node
),
2046 pp_string (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_string (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_string (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_string (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_string (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_character (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_character (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_character (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_string (buffer
, ")");
2213 if (OMP_FOR_BODY (node
))
2215 newline_and_indent (buffer
, spc
+ 2);
2216 pp_character (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_character (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_character (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_character (buffer
, '(');
2257 dump_generic_node (buffer
, OMP_CRITICAL_NAME (node
), spc
,
2259 pp_character (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);
2268 pp_character (buffer
, '=');
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);
2286 pp_character (buffer
, '=');
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_character (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_character (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
:
2345 pp_character (buffer
, ' ');
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_character (buffer
, '(');
2479 dump_generic_node (buffer
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
2480 pp_character (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
))
2492 pp_character (buffer
, '=');
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_character (buffer
, ']');
2505 pp_character (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_character (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_character (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_string (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 pp_construct (&buffer
, /* prefix */NULL
, /* line-width */0);
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_base_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
, ", cgraph_uid=%d)%s\n\n", node
->uid
,
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");