1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2014 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
26 #include "stor-layout.h"
28 #include "tree-pretty-print.h"
31 #include "gimple-expr.h"
35 #include "plugin-api.h"
38 #include "hard-reg-set.h"
43 #include "langhooks.h"
44 #include "tree-iterator.h"
45 #include "tree-chrec.h"
47 #include "value-prof.h"
48 #include "wide-int-print.h"
49 #include "internal-fn.h"
51 #include <new> // For placement-new.
53 /* Local functions, macros and variables. */
54 static const char *op_symbol (const_tree
);
55 static void pretty_print_string (pretty_printer
*, const char*);
56 static void newline_and_indent (pretty_printer
*, int);
57 static void maybe_init_pretty_print (FILE *);
58 static void print_struct_decl (pretty_printer
*, const_tree
, int, int);
59 static void do_niy (pretty_printer
*, const_tree
);
61 #define INDENT(SPACE) do { \
62 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
64 #define NIY do_niy (buffer, node)
66 static pretty_printer buffer
;
67 static int initialized
= 0;
69 /* Try to print something for an unknown tree code. */
72 do_niy (pretty_printer
*buffer
, const_tree node
)
76 pp_string (buffer
, "<<< Unknown tree: ");
77 pp_string (buffer
, get_tree_code_name (TREE_CODE (node
)));
81 len
= TREE_OPERAND_LENGTH (node
);
82 for (i
= 0; i
< len
; ++i
)
84 newline_and_indent (buffer
, 2);
85 dump_generic_node (buffer
, TREE_OPERAND (node
, i
), 2, 0, false);
89 pp_string (buffer
, " >>>");
92 /* Debugging function to print out a generic expression. */
95 debug_generic_expr (tree t
)
97 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
98 fprintf (stderr
, "\n");
101 /* Debugging function to print out a generic statement. */
104 debug_generic_stmt (tree t
)
106 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
107 fprintf (stderr
, "\n");
110 /* Debugging function to print out a chain of trees . */
113 debug_tree_chain (tree t
)
119 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
120 fprintf (stderr
, " ");
124 fprintf (stderr
, "... [cycled back to ");
125 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
126 fprintf (stderr
, "]");
130 fprintf (stderr
, "\n");
133 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
135 print_generic_decl (FILE *file
, tree decl
, int flags
)
137 maybe_init_pretty_print (file
);
138 print_declaration (&buffer
, decl
, 2, flags
);
139 pp_write_text_to_stream (&buffer
);
142 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
143 to show in the dump. See TDF_* in dumpfile.h. */
146 print_generic_stmt (FILE *file
, tree t
, int flags
)
148 maybe_init_pretty_print (file
);
149 dump_generic_node (&buffer
, t
, 0, flags
, true);
150 pp_newline_and_flush (&buffer
);
153 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
154 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
158 print_generic_stmt_indented (FILE *file
, tree t
, int flags
, int indent
)
162 maybe_init_pretty_print (file
);
164 for (i
= 0; i
< indent
; i
++)
166 dump_generic_node (&buffer
, t
, indent
, flags
, true);
167 pp_newline_and_flush (&buffer
);
170 /* Print a single expression T on file FILE. FLAGS specifies details to show
171 in the dump. See TDF_* in dumpfile.h. */
174 print_generic_expr (FILE *file
, tree t
, int flags
)
176 maybe_init_pretty_print (file
);
177 dump_generic_node (&buffer
, t
, 0, flags
, false);
181 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
185 dump_decl_name (pretty_printer
*buffer
, tree node
, int flags
)
187 if (DECL_NAME (node
))
189 if ((flags
& TDF_ASMNAME
) && DECL_ASSEMBLER_NAME_SET_P (node
))
190 pp_tree_identifier (buffer
, DECL_ASSEMBLER_NAME (node
));
192 pp_tree_identifier (buffer
, DECL_NAME (node
));
194 if ((flags
& TDF_UID
) || DECL_NAME (node
) == NULL_TREE
)
196 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
197 pp_printf (buffer
, "L.%d", (int) LABEL_DECL_UID (node
));
198 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
200 if (flags
& TDF_NOUID
)
201 pp_string (buffer
, "D#xxxx");
203 pp_printf (buffer
, "D#%i", DEBUG_TEMP_UID (node
));
207 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
208 if (flags
& TDF_NOUID
)
209 pp_printf (buffer
, "%c.xxxx", c
);
211 pp_printf (buffer
, "%c.%u", c
, DECL_UID (node
));
214 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
216 if (flags
& TDF_NOUID
)
217 pp_printf (buffer
, "ptD.xxxx");
219 pp_printf (buffer
, "ptD.%u", DECL_PT_UID (node
));
223 /* Like the above, but used for pretty printing function calls. */
226 dump_function_name (pretty_printer
*buffer
, tree node
, int flags
)
228 if (CONVERT_EXPR_P (node
))
229 node
= TREE_OPERAND (node
, 0);
230 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
231 pp_string (buffer
, lang_hooks
.decl_printable_name (node
, 1));
233 dump_decl_name (buffer
, node
, flags
);
236 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
237 FLAGS are as in dump_generic_node. */
240 dump_function_declaration (pretty_printer
*buffer
, tree node
,
243 bool wrote_arg
= false;
247 pp_left_paren (buffer
);
249 /* Print the argument types. */
250 arg
= TYPE_ARG_TYPES (node
);
251 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
259 dump_generic_node (buffer
, TREE_VALUE (arg
), spc
, flags
, false);
260 arg
= TREE_CHAIN (arg
);
263 /* Drop the trailing void_type_node if we had any previous argument. */
264 if (arg
== void_list_node
&& !wrote_arg
)
265 pp_string (buffer
, "void");
266 /* Properly dump vararg function types. */
267 else if (!arg
&& wrote_arg
)
268 pp_string (buffer
, ", ...");
269 /* Avoid printing any arg for unprototyped functions. */
271 pp_right_paren (buffer
);
274 /* Dump the domain associated with an array. */
277 dump_array_domain (pretty_printer
*buffer
, tree domain
, int spc
, int flags
)
279 pp_left_bracket (buffer
);
282 tree min
= TYPE_MIN_VALUE (domain
);
283 tree max
= TYPE_MAX_VALUE (domain
);
286 && integer_zerop (min
)
287 && tree_fits_shwi_p (max
))
288 pp_wide_integer (buffer
, tree_to_shwi (max
) + 1);
292 dump_generic_node (buffer
, min
, spc
, flags
, false);
295 dump_generic_node (buffer
, max
, spc
, flags
, false);
299 pp_string (buffer
, "<unknown>");
300 pp_right_bracket (buffer
);
304 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
305 dump_generic_node. */
308 dump_omp_clause (pretty_printer
*buffer
, tree clause
, int spc
, int flags
)
312 switch (OMP_CLAUSE_CODE (clause
))
314 case OMP_CLAUSE_PRIVATE
:
317 case OMP_CLAUSE_SHARED
:
320 case OMP_CLAUSE_FIRSTPRIVATE
:
321 name
= "firstprivate";
323 case OMP_CLAUSE_LASTPRIVATE
:
324 name
= "lastprivate";
326 case OMP_CLAUSE_COPYIN
:
329 case OMP_CLAUSE_COPYPRIVATE
:
330 name
= "copyprivate";
332 case OMP_CLAUSE_UNIFORM
:
335 case OMP_CLAUSE__LOOPTEMP_
:
339 pp_string (buffer
, name
);
340 pp_left_paren (buffer
);
341 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
343 pp_right_paren (buffer
);
346 case OMP_CLAUSE_REDUCTION
:
347 pp_string (buffer
, "reduction(");
348 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
351 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
354 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
356 pp_right_paren (buffer
);
360 pp_string (buffer
, "if(");
361 dump_generic_node (buffer
, OMP_CLAUSE_IF_EXPR (clause
),
363 pp_right_paren (buffer
);
366 case OMP_CLAUSE_NUM_THREADS
:
367 pp_string (buffer
, "num_threads(");
368 dump_generic_node (buffer
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
370 pp_right_paren (buffer
);
373 case OMP_CLAUSE__CILK_FOR_COUNT_
:
374 pp_string (buffer
, "_Cilk_for_count_(");
375 dump_generic_node (buffer
, OMP_CLAUSE_OPERAND (clause
, 0),
377 pp_right_paren (buffer
);
380 case OMP_CLAUSE_NOWAIT
:
381 pp_string (buffer
, "nowait");
383 case OMP_CLAUSE_ORDERED
:
384 pp_string (buffer
, "ordered");
387 case OMP_CLAUSE_DEFAULT
:
388 pp_string (buffer
, "default(");
389 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
391 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
393 case OMP_CLAUSE_DEFAULT_SHARED
:
394 pp_string (buffer
, "shared");
396 case OMP_CLAUSE_DEFAULT_NONE
:
397 pp_string (buffer
, "none");
399 case OMP_CLAUSE_DEFAULT_PRIVATE
:
400 pp_string (buffer
, "private");
402 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
403 pp_string (buffer
, "firstprivate");
408 pp_right_paren (buffer
);
411 case OMP_CLAUSE_SCHEDULE
:
412 pp_string (buffer
, "schedule(");
413 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
))
415 case OMP_CLAUSE_SCHEDULE_STATIC
:
416 pp_string (buffer
, "static");
418 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
419 pp_string (buffer
, "dynamic");
421 case OMP_CLAUSE_SCHEDULE_GUIDED
:
422 pp_string (buffer
, "guided");
424 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
425 pp_string (buffer
, "runtime");
427 case OMP_CLAUSE_SCHEDULE_AUTO
:
428 pp_string (buffer
, "auto");
430 case OMP_CLAUSE_SCHEDULE_CILKFOR
:
431 pp_string (buffer
, "cilk-for grain");
436 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
439 dump_generic_node (buffer
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
442 pp_right_paren (buffer
);
445 case OMP_CLAUSE_UNTIED
:
446 pp_string (buffer
, "untied");
449 case OMP_CLAUSE_COLLAPSE
:
450 pp_string (buffer
, "collapse(");
451 dump_generic_node (buffer
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
453 pp_right_paren (buffer
);
456 case OMP_CLAUSE_FINAL
:
457 pp_string (buffer
, "final(");
458 dump_generic_node (buffer
, OMP_CLAUSE_FINAL_EXPR (clause
),
460 pp_right_paren (buffer
);
463 case OMP_CLAUSE_MERGEABLE
:
464 pp_string (buffer
, "mergeable");
467 case OMP_CLAUSE_LINEAR
:
468 pp_string (buffer
, "linear(");
469 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
472 dump_generic_node (buffer
, OMP_CLAUSE_LINEAR_STEP (clause
),
474 pp_right_paren (buffer
);
477 case OMP_CLAUSE_ALIGNED
:
478 pp_string (buffer
, "aligned(");
479 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
481 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
484 dump_generic_node (buffer
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
487 pp_right_paren (buffer
);
490 case OMP_CLAUSE_DEPEND
:
491 pp_string (buffer
, "depend(");
492 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
494 case OMP_CLAUSE_DEPEND_IN
:
495 pp_string (buffer
, "in");
497 case OMP_CLAUSE_DEPEND_OUT
:
498 pp_string (buffer
, "out");
500 case OMP_CLAUSE_DEPEND_INOUT
:
501 pp_string (buffer
, "inout");
507 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
509 pp_right_paren (buffer
);
513 pp_string (buffer
, "map(");
514 switch (OMP_CLAUSE_MAP_KIND (clause
))
516 case OMP_CLAUSE_MAP_ALLOC
:
517 case OMP_CLAUSE_MAP_POINTER
:
518 pp_string (buffer
, "alloc");
520 case OMP_CLAUSE_MAP_TO
:
521 case OMP_CLAUSE_MAP_TO_PSET
:
522 pp_string (buffer
, "to");
524 case OMP_CLAUSE_MAP_FROM
:
525 pp_string (buffer
, "from");
527 case OMP_CLAUSE_MAP_TOFROM
:
528 pp_string (buffer
, "tofrom");
534 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
537 if (OMP_CLAUSE_SIZE (clause
))
539 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
540 && OMP_CLAUSE_MAP_KIND (clause
) == OMP_CLAUSE_MAP_POINTER
)
541 pp_string (buffer
, " [pointer assign, bias: ");
542 else if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
543 && OMP_CLAUSE_MAP_KIND (clause
) == OMP_CLAUSE_MAP_TO_PSET
)
544 pp_string (buffer
, " [pointer set, len: ");
546 pp_string (buffer
, " [len: ");
547 dump_generic_node (buffer
, OMP_CLAUSE_SIZE (clause
),
549 pp_right_bracket (buffer
);
551 pp_right_paren (buffer
);
554 case OMP_CLAUSE_FROM
:
555 pp_string (buffer
, "from(");
556 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
558 goto print_clause_size
;
561 pp_string (buffer
, "to(");
562 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
564 goto print_clause_size
;
566 case OMP_CLAUSE_NUM_TEAMS
:
567 pp_string (buffer
, "num_teams(");
568 dump_generic_node (buffer
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
570 pp_right_paren (buffer
);
573 case OMP_CLAUSE_THREAD_LIMIT
:
574 pp_string (buffer
, "thread_limit(");
575 dump_generic_node (buffer
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
577 pp_right_paren (buffer
);
580 case OMP_CLAUSE_DEVICE
:
581 pp_string (buffer
, "device(");
582 dump_generic_node (buffer
, OMP_CLAUSE_DEVICE_ID (clause
),
584 pp_right_paren (buffer
);
587 case OMP_CLAUSE_DIST_SCHEDULE
:
588 pp_string (buffer
, "dist_schedule(static");
589 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
592 dump_generic_node (buffer
,
593 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
596 pp_right_paren (buffer
);
599 case OMP_CLAUSE_PROC_BIND
:
600 pp_string (buffer
, "proc_bind(");
601 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
603 case OMP_CLAUSE_PROC_BIND_MASTER
:
604 pp_string (buffer
, "master");
606 case OMP_CLAUSE_PROC_BIND_CLOSE
:
607 pp_string (buffer
, "close");
609 case OMP_CLAUSE_PROC_BIND_SPREAD
:
610 pp_string (buffer
, "spread");
615 pp_right_paren (buffer
);
618 case OMP_CLAUSE_SAFELEN
:
619 pp_string (buffer
, "safelen(");
620 dump_generic_node (buffer
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
622 pp_right_paren (buffer
);
625 case OMP_CLAUSE_SIMDLEN
:
626 pp_string (buffer
, "simdlen(");
627 dump_generic_node (buffer
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
629 pp_right_paren (buffer
);
632 case OMP_CLAUSE__SIMDUID_
:
633 pp_string (buffer
, "_simduid_(");
634 dump_generic_node (buffer
, OMP_CLAUSE__SIMDUID__DECL (clause
),
636 pp_right_paren (buffer
);
639 case OMP_CLAUSE_INBRANCH
:
640 pp_string (buffer
, "inbranch");
642 case OMP_CLAUSE_NOTINBRANCH
:
643 pp_string (buffer
, "notinbranch");
646 pp_string (buffer
, "for");
648 case OMP_CLAUSE_PARALLEL
:
649 pp_string (buffer
, "parallel");
651 case OMP_CLAUSE_SECTIONS
:
652 pp_string (buffer
, "sections");
654 case OMP_CLAUSE_TASKGROUP
:
655 pp_string (buffer
, "taskgroup");
659 /* Should never happen. */
660 dump_generic_node (buffer
, clause
, spc
, flags
, false);
666 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
667 dump_generic_node. */
670 dump_omp_clauses (pretty_printer
*buffer
, tree clause
, int spc
, int flags
)
678 dump_omp_clause (buffer
, clause
, spc
, flags
);
679 clause
= OMP_CLAUSE_CHAIN (clause
);
687 /* Dump location LOC to BUFFER. */
690 dump_location (pretty_printer
*buffer
, location_t loc
)
692 expanded_location xloc
= expand_location (loc
);
694 pp_left_bracket (buffer
);
697 pp_string (buffer
, xloc
.file
);
698 pp_string (buffer
, ":");
700 pp_decimal_int (buffer
, xloc
.line
);
702 pp_decimal_int (buffer
, xloc
.column
);
703 pp_string (buffer
, "] ");
707 /* Dump lexical block BLOCK. BUFFER, SPC and FLAGS are as in
708 dump_generic_node. */
711 dump_block_node (pretty_printer
*buffer
, tree block
, int spc
, int flags
)
715 pp_printf (buffer
, "BLOCK #%d ", BLOCK_NUMBER (block
));
717 if (flags
& TDF_ADDRESS
)
718 pp_printf (buffer
, "[%p] ", (void *) block
);
720 if (BLOCK_ABSTRACT (block
))
721 pp_string (buffer
, "[abstract] ");
723 if (TREE_ASM_WRITTEN (block
))
724 pp_string (buffer
, "[written] ");
726 if (flags
& TDF_SLIM
)
729 if (BLOCK_SOURCE_LOCATION (block
))
730 dump_location (buffer
, BLOCK_SOURCE_LOCATION (block
));
732 newline_and_indent (buffer
, spc
+ 2);
734 if (BLOCK_SUPERCONTEXT (block
))
736 pp_string (buffer
, "SUPERCONTEXT: ");
737 dump_generic_node (buffer
, BLOCK_SUPERCONTEXT (block
), 0,
738 flags
| TDF_SLIM
, false);
739 newline_and_indent (buffer
, spc
+ 2);
742 if (BLOCK_SUBBLOCKS (block
))
744 pp_string (buffer
, "SUBBLOCKS: ");
745 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
747 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
750 newline_and_indent (buffer
, spc
+ 2);
753 if (BLOCK_CHAIN (block
))
755 pp_string (buffer
, "SIBLINGS: ");
756 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
758 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
761 newline_and_indent (buffer
, spc
+ 2);
764 if (BLOCK_VARS (block
))
766 pp_string (buffer
, "VARS: ");
767 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
769 dump_generic_node (buffer
, t
, 0, flags
, false);
772 newline_and_indent (buffer
, spc
+ 2);
775 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
778 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
780 pp_string (buffer
, "NONLOCALIZED_VARS: ");
781 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
783 dump_generic_node (buffer
, t
, 0, flags
, false);
786 newline_and_indent (buffer
, spc
+ 2);
789 if (BLOCK_ABSTRACT_ORIGIN (block
))
791 pp_string (buffer
, "ABSTRACT_ORIGIN: ");
792 dump_generic_node (buffer
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
793 flags
| TDF_SLIM
, false);
794 newline_and_indent (buffer
, spc
+ 2);
797 if (BLOCK_FRAGMENT_ORIGIN (block
))
799 pp_string (buffer
, "FRAGMENT_ORIGIN: ");
800 dump_generic_node (buffer
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
801 flags
| TDF_SLIM
, false);
802 newline_and_indent (buffer
, spc
+ 2);
805 if (BLOCK_FRAGMENT_CHAIN (block
))
807 pp_string (buffer
, "FRAGMENT_CHAIN: ");
808 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
810 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
813 newline_and_indent (buffer
, spc
+ 2);
818 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
819 indent. FLAGS specifies details to show in the dump (see TDF_* in
820 dumpfile.h). If IS_STMT is true, the object printed is considered
821 to be a statement and it is terminated by ';' if appropriate. */
824 dump_generic_node (pretty_printer
*buffer
, tree node
, int spc
, int flags
,
833 if (node
== NULL_TREE
)
836 is_expr
= EXPR_P (node
);
838 if (is_stmt
&& (flags
& TDF_STMTADDR
))
839 pp_printf (buffer
, "<&%p> ", (void *)node
);
841 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
842 dump_location (buffer
, EXPR_LOCATION (node
));
844 code
= TREE_CODE (node
);
848 pp_string (buffer
, "<<< error >>>");
851 case IDENTIFIER_NODE
:
852 pp_tree_identifier (buffer
, node
);
856 while (node
&& node
!= error_mark_node
)
858 if (TREE_PURPOSE (node
))
860 dump_generic_node (buffer
, TREE_PURPOSE (node
), spc
, flags
, false);
863 dump_generic_node (buffer
, TREE_VALUE (node
), spc
, flags
, false);
864 node
= TREE_CHAIN (node
);
865 if (node
&& TREE_CODE (node
) == TREE_LIST
)
874 dump_generic_node (buffer
, BINFO_TYPE (node
), spc
, flags
, false);
880 if (TREE_VEC_LENGTH (node
) > 0)
882 size_t len
= TREE_VEC_LENGTH (node
);
883 for (i
= 0; i
< len
- 1; i
++)
885 dump_generic_node (buffer
, TREE_VEC_ELT (node
, i
), spc
, flags
,
890 dump_generic_node (buffer
, TREE_VEC_ELT (node
, len
- 1), spc
,
897 case POINTER_BOUNDS_TYPE
:
900 case FIXED_POINT_TYPE
:
906 unsigned int quals
= TYPE_QUALS (node
);
907 enum tree_code_class tclass
;
909 if (quals
& TYPE_QUAL_ATOMIC
)
910 pp_string (buffer
, "atomic ");
911 if (quals
& TYPE_QUAL_CONST
)
912 pp_string (buffer
, "const ");
913 else if (quals
& TYPE_QUAL_VOLATILE
)
914 pp_string (buffer
, "volatile ");
915 else if (quals
& TYPE_QUAL_RESTRICT
)
916 pp_string (buffer
, "restrict ");
918 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
920 pp_string (buffer
, "<address-space-");
921 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
922 pp_string (buffer
, "> ");
925 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
927 if (tclass
== tcc_declaration
)
929 if (DECL_NAME (node
))
930 dump_decl_name (buffer
, node
, flags
);
932 pp_string (buffer
, "<unnamed type decl>");
934 else if (tclass
== tcc_type
)
936 if (TYPE_NAME (node
))
938 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
939 pp_tree_identifier (buffer
, TYPE_NAME (node
));
940 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
941 && DECL_NAME (TYPE_NAME (node
)))
942 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
944 pp_string (buffer
, "<unnamed type>");
946 else if (TREE_CODE (node
) == VECTOR_TYPE
)
948 pp_string (buffer
, "vector");
949 pp_left_paren (buffer
);
950 pp_wide_integer (buffer
, TYPE_VECTOR_SUBPARTS (node
));
951 pp_string (buffer
, ") ");
952 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
954 else if (TREE_CODE (node
) == INTEGER_TYPE
)
956 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
957 pp_string (buffer
, (TYPE_UNSIGNED (node
)
960 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
961 pp_string (buffer
, (TYPE_UNSIGNED (node
)
964 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
965 pp_string (buffer
, (TYPE_UNSIGNED (node
)
968 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
969 pp_string (buffer
, (TYPE_UNSIGNED (node
)
972 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
973 pp_string (buffer
, (TYPE_UNSIGNED (node
)
974 ? "unsigned long long"
975 : "signed long long"));
976 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
977 && exact_log2 (TYPE_PRECISION (node
)) != -1)
979 pp_string (buffer
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
980 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
981 pp_string (buffer
, "_t");
985 pp_string (buffer
, (TYPE_UNSIGNED (node
)
986 ? "<unnamed-unsigned:"
987 : "<unnamed-signed:"));
988 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
992 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
994 pp_string (buffer
, "__complex__ ");
995 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
997 else if (TREE_CODE (node
) == REAL_TYPE
)
999 pp_string (buffer
, "<float:");
1000 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
1001 pp_greater (buffer
);
1003 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1005 pp_string (buffer
, "<fixed-point-");
1006 pp_string (buffer
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1007 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
1008 pp_greater (buffer
);
1010 else if (TREE_CODE (node
) == VOID_TYPE
)
1011 pp_string (buffer
, "void");
1013 pp_string (buffer
, "<unnamed type>");
1019 case REFERENCE_TYPE
:
1020 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1022 if (TREE_TYPE (node
) == NULL
)
1024 pp_string (buffer
, str
);
1025 pp_string (buffer
, "<null type>");
1027 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1029 tree fnode
= TREE_TYPE (node
);
1031 dump_generic_node (buffer
, TREE_TYPE (fnode
), spc
, flags
, false);
1033 pp_left_paren (buffer
);
1034 pp_string (buffer
, str
);
1035 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1036 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
1037 else if (flags
& TDF_NOUID
)
1038 pp_printf (buffer
, "<Txxxx>");
1040 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
1042 pp_right_paren (buffer
);
1043 dump_function_declaration (buffer
, fnode
, spc
, flags
);
1047 unsigned int quals
= TYPE_QUALS (node
);
1049 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1051 pp_string (buffer
, str
);
1053 if (quals
& TYPE_QUAL_CONST
)
1054 pp_string (buffer
, " const");
1055 if (quals
& TYPE_QUAL_VOLATILE
)
1056 pp_string (buffer
, " volatile");
1057 if (quals
& TYPE_QUAL_RESTRICT
)
1058 pp_string (buffer
, " restrict");
1060 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1062 pp_string (buffer
, " <address-space-");
1063 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
1064 pp_greater (buffer
);
1067 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1068 pp_string (buffer
, " {ref-all}");
1078 if (integer_zerop (TREE_OPERAND (node
, 1))
1079 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1080 infer them and MEM_ATTR caching will share MEM_REFs
1081 with differently-typed op0s. */
1082 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1083 /* Released SSA_NAMES have no TREE_TYPE. */
1084 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1085 /* Same pointer types, but ignoring POINTER_TYPE vs.
1087 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1088 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1089 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1090 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1091 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1092 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1093 /* Same value types ignoring qualifiers. */
1094 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1095 == TYPE_MAIN_VARIANT
1096 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))))
1098 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1101 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1105 dump_generic_node (buffer
,
1106 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1113 pp_string (buffer
, "MEM[");
1114 pp_left_paren (buffer
);
1115 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1116 dump_generic_node (buffer
, ptype
,
1117 spc
, flags
| TDF_SLIM
, false);
1118 pp_right_paren (buffer
);
1119 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1121 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1123 pp_string (buffer
, " + ");
1124 dump_generic_node (buffer
, TREE_OPERAND (node
, 1),
1127 pp_right_bracket (buffer
);
1132 case TARGET_MEM_REF
:
1134 const char *sep
= "";
1137 pp_string (buffer
, "MEM[");
1139 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1141 pp_string (buffer
, sep
);
1143 pp_string (buffer
, "symbol: ");
1144 dump_generic_node (buffer
, TREE_OPERAND (TMR_BASE (node
), 0),
1149 pp_string (buffer
, sep
);
1151 pp_string (buffer
, "base: ");
1152 dump_generic_node (buffer
, TMR_BASE (node
), spc
, flags
, false);
1154 tmp
= TMR_INDEX2 (node
);
1157 pp_string (buffer
, sep
);
1159 pp_string (buffer
, "base: ");
1160 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1162 tmp
= TMR_INDEX (node
);
1165 pp_string (buffer
, sep
);
1167 pp_string (buffer
, "index: ");
1168 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1170 tmp
= TMR_STEP (node
);
1173 pp_string (buffer
, sep
);
1175 pp_string (buffer
, "step: ");
1176 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1178 tmp
= TMR_OFFSET (node
);
1181 pp_string (buffer
, sep
);
1183 pp_string (buffer
, "offset: ");
1184 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1186 pp_right_bracket (buffer
);
1194 /* Print the innermost component type. */
1195 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1196 tmp
= TREE_TYPE (tmp
))
1198 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1200 /* Print the dimensions. */
1201 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1202 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
1208 case QUAL_UNION_TYPE
:
1210 unsigned int quals
= TYPE_QUALS (node
);
1212 if (quals
& TYPE_QUAL_ATOMIC
)
1213 pp_string (buffer
, "atomic ");
1214 if (quals
& TYPE_QUAL_CONST
)
1215 pp_string (buffer
, "const ");
1216 if (quals
& TYPE_QUAL_VOLATILE
)
1217 pp_string (buffer
, "volatile ");
1219 /* Print the name of the structure. */
1220 if (TREE_CODE (node
) == RECORD_TYPE
)
1221 pp_string (buffer
, "struct ");
1222 else if (TREE_CODE (node
) == UNION_TYPE
)
1223 pp_string (buffer
, "union ");
1225 if (TYPE_NAME (node
))
1226 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, flags
, false);
1227 else if (!(flags
& TDF_SLIM
))
1228 /* FIXME: If we eliminate the 'else' above and attempt
1229 to show the fields for named types, we may get stuck
1230 following a cycle of pointers to structs. The alleged
1231 self-reference check in print_struct_decl will not detect
1232 cycles involving more than one pointer or struct type. */
1233 print_struct_decl (buffer
, node
, spc
, flags
);
1242 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
1244 /* In the case of a pointer, one may want to divide by the
1245 size of the pointed-to type. Unfortunately, this not
1246 straightforward. The C front-end maps expressions
1251 in such a way that the two INTEGER_CST nodes for "5" have
1252 different values but identical types. In the latter
1253 case, the 5 is multiplied by sizeof (int) in c-common.c
1254 (pointer_int_sum) to convert it to a byte address, and
1255 yet the type of the node is left unchanged. Argh. What
1256 is consistent though is that the number value corresponds
1257 to bytes (UNITS) offset.
1259 NB: Neither of the following divisors can be trivially
1260 used to recover the original literal:
1262 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1263 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1264 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
1265 pp_string (buffer
, "B"); /* pseudo-unit */
1267 else if (tree_fits_shwi_p (node
))
1268 pp_wide_integer (buffer
, tree_to_shwi (node
));
1269 else if (tree_fits_uhwi_p (node
))
1270 pp_unsigned_wide_integer (buffer
, tree_to_uhwi (node
));
1273 wide_int val
= node
;
1275 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1280 print_hex (val
, pp_buffer (buffer
)->digit_buffer
);
1281 pp_string (buffer
, pp_buffer (buffer
)->digit_buffer
);
1283 if (TREE_OVERFLOW (node
))
1284 pp_string (buffer
, "(OVF)");
1288 /* Code copied from print_node. */
1291 if (TREE_OVERFLOW (node
))
1292 pp_string (buffer
, " overflow");
1294 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
1295 d
= TREE_REAL_CST (node
);
1296 if (REAL_VALUE_ISINF (d
))
1297 pp_string (buffer
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1298 else if (REAL_VALUE_ISNAN (d
))
1299 pp_string (buffer
, " Nan");
1303 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1304 pp_string (buffer
, string
);
1309 unsigned char *p
= (unsigned char *) &TREE_REAL_CST (node
);
1310 pp_string (buffer
, "0x");
1311 for (i
= 0; i
< sizeof TREE_REAL_CST (node
); i
++)
1312 output_formatted_integer (buffer
, "%02x", *p
++);
1321 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1322 pp_string (buffer
, string
);
1327 pp_string (buffer
, "__complex__ (");
1328 dump_generic_node (buffer
, TREE_REALPART (node
), spc
, flags
, false);
1329 pp_string (buffer
, ", ");
1330 dump_generic_node (buffer
, TREE_IMAGPART (node
), spc
, flags
, false);
1331 pp_right_paren (buffer
);
1335 pp_string (buffer
, "\"");
1336 pretty_print_string (buffer
, TREE_STRING_POINTER (node
));
1337 pp_string (buffer
, "\"");
1343 pp_string (buffer
, "{ ");
1344 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1347 pp_string (buffer
, ", ");
1348 dump_generic_node (buffer
, VECTOR_CST_ELT (node
, i
),
1351 pp_string (buffer
, " }");
1357 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1359 if (TREE_CODE (node
) == METHOD_TYPE
)
1361 if (TYPE_METHOD_BASETYPE (node
))
1362 dump_decl_name (buffer
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1365 pp_string (buffer
, "<null method basetype>");
1366 pp_colon_colon (buffer
);
1368 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1369 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
1370 else if (flags
& TDF_NOUID
)
1371 pp_printf (buffer
, "<Txxxx>");
1373 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
1374 dump_function_declaration (buffer
, node
, spc
, flags
);
1379 dump_decl_name (buffer
, node
, flags
);
1383 if (DECL_NAME (node
))
1384 dump_decl_name (buffer
, node
, flags
);
1385 else if (LABEL_DECL_UID (node
) != -1)
1386 pp_printf (buffer
, "<L%d>", (int) LABEL_DECL_UID (node
));
1389 if (flags
& TDF_NOUID
)
1390 pp_string (buffer
, "<D.xxxx>");
1392 pp_printf (buffer
, "<D.%u>", DECL_UID (node
));
1397 if (DECL_IS_BUILTIN (node
))
1399 /* Don't print the declaration of built-in types. */
1402 if (DECL_NAME (node
))
1403 dump_decl_name (buffer
, node
, flags
);
1404 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1406 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1407 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1408 && TYPE_METHODS (TREE_TYPE (node
)))
1410 /* The type is a c++ class: all structures have at least
1412 pp_string (buffer
, "class ");
1413 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1418 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1419 ? "union" : "struct "));
1420 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1424 pp_string (buffer
, "<anon>");
1430 case DEBUG_EXPR_DECL
:
1431 case NAMESPACE_DECL
:
1433 dump_decl_name (buffer
, node
, flags
);
1437 pp_string (buffer
, "<retval>");
1441 op0
= TREE_OPERAND (node
, 0);
1444 && (TREE_CODE (op0
) == INDIRECT_REF
1445 || (TREE_CODE (op0
) == MEM_REF
1446 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1447 && integer_zerop (TREE_OPERAND (op0
, 1))
1448 /* Dump the types of INTEGER_CSTs explicitly, for we
1449 can't infer them and MEM_ATTR caching will share
1450 MEM_REFs with differently-typed op0s. */
1451 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1452 /* Released SSA_NAMES have no TREE_TYPE. */
1453 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1454 /* Same pointer types, but ignoring POINTER_TYPE vs.
1456 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1457 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1458 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1459 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1460 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1461 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1462 /* Same value types ignoring qualifiers. */
1463 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1464 == TYPE_MAIN_VARIANT
1465 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))))))
1467 op0
= TREE_OPERAND (op0
, 0);
1470 if (op_prio (op0
) < op_prio (node
))
1471 pp_left_paren (buffer
);
1472 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1473 if (op_prio (op0
) < op_prio (node
))
1474 pp_right_paren (buffer
);
1475 pp_string (buffer
, str
);
1476 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1477 op0
= component_ref_field_offset (node
);
1478 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1480 pp_string (buffer
, "{off: ");
1481 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1482 pp_right_brace (buffer
);
1487 pp_string (buffer
, "BIT_FIELD_REF <");
1488 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1489 pp_string (buffer
, ", ");
1490 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1491 pp_string (buffer
, ", ");
1492 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1493 pp_greater (buffer
);
1497 case ARRAY_RANGE_REF
:
1498 op0
= TREE_OPERAND (node
, 0);
1499 if (op_prio (op0
) < op_prio (node
))
1500 pp_left_paren (buffer
);
1501 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1502 if (op_prio (op0
) < op_prio (node
))
1503 pp_right_paren (buffer
);
1504 pp_left_bracket (buffer
);
1505 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1506 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1507 pp_string (buffer
, " ...");
1508 pp_right_bracket (buffer
);
1510 op0
= array_ref_low_bound (node
);
1511 op1
= array_ref_element_size (node
);
1513 if (!integer_zerop (op0
)
1514 || TREE_OPERAND (node
, 2)
1515 || TREE_OPERAND (node
, 3))
1517 pp_string (buffer
, "{lb: ");
1518 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1519 pp_string (buffer
, " sz: ");
1520 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1521 pp_right_brace (buffer
);
1527 unsigned HOST_WIDE_INT ix
;
1529 bool is_struct_init
= false;
1530 bool is_array_init
= false;
1532 pp_left_brace (buffer
);
1533 if (TREE_CLOBBER_P (node
))
1534 pp_string (buffer
, "CLOBBER");
1535 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1536 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1537 is_struct_init
= true;
1538 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
1539 && TYPE_DOMAIN (TREE_TYPE (node
))
1540 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
1541 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
1544 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
1545 is_array_init
= true;
1546 curidx
= wi::to_widest (minv
);
1548 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1555 dump_generic_node (buffer
, field
, spc
, flags
, false);
1558 else if (is_array_init
1559 && (TREE_CODE (field
) != INTEGER_CST
1560 || curidx
!= wi::to_widest (field
)))
1562 pp_left_bracket (buffer
);
1563 if (TREE_CODE (field
) == RANGE_EXPR
)
1565 dump_generic_node (buffer
, TREE_OPERAND (field
, 0), spc
,
1567 pp_string (buffer
, " ... ");
1568 dump_generic_node (buffer
, TREE_OPERAND (field
, 1), spc
,
1570 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
1571 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
1574 dump_generic_node (buffer
, field
, spc
, flags
, false);
1575 if (TREE_CODE (field
) == INTEGER_CST
)
1576 curidx
= wi::to_widest (field
);
1577 pp_string (buffer
, "]=");
1582 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1583 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1584 val
= TREE_OPERAND (val
, 0);
1585 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1586 dump_decl_name (buffer
, val
, flags
);
1588 dump_generic_node (buffer
, val
, spc
, flags
, false);
1589 if (ix
!= vec_safe_length (CONSTRUCTOR_ELTS (node
)) - 1)
1595 pp_right_brace (buffer
);
1602 if (flags
& TDF_SLIM
)
1604 pp_string (buffer
, "<COMPOUND_EXPR>");
1608 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1609 spc
, flags
, !(flags
& TDF_SLIM
));
1610 if (flags
& TDF_SLIM
)
1611 newline_and_indent (buffer
, spc
);
1618 for (tp
= &TREE_OPERAND (node
, 1);
1619 TREE_CODE (*tp
) == COMPOUND_EXPR
;
1620 tp
= &TREE_OPERAND (*tp
, 1))
1622 dump_generic_node (buffer
, TREE_OPERAND (*tp
, 0),
1623 spc
, flags
, !(flags
& TDF_SLIM
));
1624 if (flags
& TDF_SLIM
)
1625 newline_and_indent (buffer
, spc
);
1633 dump_generic_node (buffer
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
1637 case STATEMENT_LIST
:
1639 tree_stmt_iterator si
;
1642 if (flags
& TDF_SLIM
)
1644 pp_string (buffer
, "<STATEMENT_LIST>");
1648 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
1651 newline_and_indent (buffer
, spc
);
1654 dump_generic_node (buffer
, tsi_stmt (si
), spc
, flags
, true);
1661 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
,
1666 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
,
1671 pp_string (buffer
, "TARGET_EXPR <");
1672 dump_generic_node (buffer
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
1675 dump_generic_node (buffer
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
1676 pp_greater (buffer
);
1680 print_declaration (buffer
, DECL_EXPR_DECL (node
), spc
, flags
);
1685 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
1687 pp_string (buffer
, "if (");
1688 dump_generic_node (buffer
, COND_EXPR_COND (node
), spc
, flags
, false);
1689 pp_right_paren (buffer
);
1690 /* The lowered cond_exprs should always be printed in full. */
1691 if (COND_EXPR_THEN (node
)
1692 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
1693 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
1694 && COND_EXPR_ELSE (node
)
1695 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
1696 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
1699 dump_generic_node (buffer
, COND_EXPR_THEN (node
),
1701 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1703 pp_string (buffer
, " else ");
1704 dump_generic_node (buffer
, COND_EXPR_ELSE (node
),
1708 else if (!(flags
& TDF_SLIM
))
1710 /* Output COND_EXPR_THEN. */
1711 if (COND_EXPR_THEN (node
))
1713 newline_and_indent (buffer
, spc
+2);
1714 pp_left_brace (buffer
);
1715 newline_and_indent (buffer
, spc
+4);
1716 dump_generic_node (buffer
, COND_EXPR_THEN (node
), spc
+4,
1718 newline_and_indent (buffer
, spc
+2);
1719 pp_right_brace (buffer
);
1722 /* Output COND_EXPR_ELSE. */
1723 if (COND_EXPR_ELSE (node
)
1724 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1726 newline_and_indent (buffer
, spc
);
1727 pp_string (buffer
, "else");
1728 newline_and_indent (buffer
, spc
+2);
1729 pp_left_brace (buffer
);
1730 newline_and_indent (buffer
, spc
+4);
1731 dump_generic_node (buffer
, COND_EXPR_ELSE (node
), spc
+4,
1733 newline_and_indent (buffer
, spc
+2);
1734 pp_right_brace (buffer
);
1741 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1743 pp_question (buffer
);
1745 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1749 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1754 pp_left_brace (buffer
);
1755 if (!(flags
& TDF_SLIM
))
1757 if (BIND_EXPR_VARS (node
))
1759 pp_newline (buffer
);
1761 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
1763 print_declaration (buffer
, op0
, spc
+2, flags
);
1764 pp_newline (buffer
);
1768 newline_and_indent (buffer
, spc
+2);
1769 dump_generic_node (buffer
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
1770 newline_and_indent (buffer
, spc
);
1771 pp_right_brace (buffer
);
1777 if (CALL_EXPR_FN (node
) != NULL_TREE
)
1778 print_call_name (buffer
, CALL_EXPR_FN (node
), flags
);
1780 pp_string (buffer
, internal_fn_name (CALL_EXPR_IFN (node
)));
1782 /* Print parameters. */
1784 pp_left_paren (buffer
);
1787 call_expr_arg_iterator iter
;
1788 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
1790 dump_generic_node (buffer
, arg
, spc
, flags
, false);
1791 if (more_call_expr_args_p (&iter
))
1798 if (CALL_EXPR_VA_ARG_PACK (node
))
1800 if (call_expr_nargs (node
) > 0)
1805 pp_string (buffer
, "__builtin_va_arg_pack ()");
1807 pp_right_paren (buffer
);
1809 op1
= CALL_EXPR_STATIC_CHAIN (node
);
1812 pp_string (buffer
, " [static-chain: ");
1813 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1814 pp_right_bracket (buffer
);
1817 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
1818 pp_string (buffer
, " [return slot optimization]");
1819 if (CALL_EXPR_TAILCALL (node
))
1820 pp_string (buffer
, " [tail call]");
1823 case WITH_CLEANUP_EXPR
:
1827 case CLEANUP_POINT_EXPR
:
1828 pp_string (buffer
, "<<cleanup_point ");
1829 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1830 pp_string (buffer
, ">>");
1833 case PLACEHOLDER_EXPR
:
1834 pp_string (buffer
, "<PLACEHOLDER_EXPR ");
1835 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1836 pp_greater (buffer
);
1839 /* Binary arithmetic and logic expressions. */
1840 case WIDEN_SUM_EXPR
:
1841 case WIDEN_MULT_EXPR
:
1843 case MULT_HIGHPART_EXPR
:
1845 case POINTER_PLUS_EXPR
:
1847 case TRUNC_DIV_EXPR
:
1849 case FLOOR_DIV_EXPR
:
1850 case ROUND_DIV_EXPR
:
1851 case TRUNC_MOD_EXPR
:
1853 case FLOOR_MOD_EXPR
:
1854 case ROUND_MOD_EXPR
:
1856 case EXACT_DIV_EXPR
:
1861 case VEC_RSHIFT_EXPR
:
1862 case WIDEN_LSHIFT_EXPR
:
1866 case TRUTH_ANDIF_EXPR
:
1867 case TRUTH_ORIF_EXPR
:
1868 case TRUTH_AND_EXPR
:
1870 case TRUTH_XOR_EXPR
:
1884 case UNORDERED_EXPR
:
1886 const char *op
= op_symbol (node
);
1887 op0
= TREE_OPERAND (node
, 0);
1888 op1
= TREE_OPERAND (node
, 1);
1890 /* When the operands are expressions with less priority,
1891 keep semantics of the tree representation. */
1892 if (op_prio (op0
) <= op_prio (node
))
1894 pp_left_paren (buffer
);
1895 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1896 pp_right_paren (buffer
);
1899 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1902 pp_string (buffer
, op
);
1905 /* When the operands are expressions with less priority,
1906 keep semantics of the tree representation. */
1907 if (op_prio (op1
) <= op_prio (node
))
1909 pp_left_paren (buffer
);
1910 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1911 pp_right_paren (buffer
);
1914 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1918 /* Unary arithmetic and logic expressions. */
1921 case TRUTH_NOT_EXPR
:
1923 case PREDECREMENT_EXPR
:
1924 case PREINCREMENT_EXPR
:
1926 if (TREE_CODE (node
) == ADDR_EXPR
1927 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
1928 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
1929 ; /* Do not output '&' for strings and function pointers. */
1931 pp_string (buffer
, op_symbol (node
));
1933 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1935 pp_left_paren (buffer
);
1936 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1937 pp_right_paren (buffer
);
1940 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1943 case POSTDECREMENT_EXPR
:
1944 case POSTINCREMENT_EXPR
:
1945 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1947 pp_left_paren (buffer
);
1948 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1949 pp_right_paren (buffer
);
1952 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1953 pp_string (buffer
, op_symbol (node
));
1957 pp_string (buffer
, "MIN_EXPR <");
1958 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1959 pp_string (buffer
, ", ");
1960 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1961 pp_greater (buffer
);
1965 pp_string (buffer
, "MAX_EXPR <");
1966 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1967 pp_string (buffer
, ", ");
1968 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1969 pp_greater (buffer
);
1973 pp_string (buffer
, "ABS_EXPR <");
1974 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1975 pp_greater (buffer
);
1982 case ADDR_SPACE_CONVERT_EXPR
:
1983 case FIXED_CONVERT_EXPR
:
1984 case FIX_TRUNC_EXPR
:
1987 type
= TREE_TYPE (node
);
1988 op0
= TREE_OPERAND (node
, 0);
1989 if (type
!= TREE_TYPE (op0
))
1991 pp_left_paren (buffer
);
1992 dump_generic_node (buffer
, type
, spc
, flags
, false);
1993 pp_string (buffer
, ") ");
1995 if (op_prio (op0
) < op_prio (node
))
1996 pp_left_paren (buffer
);
1997 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1998 if (op_prio (op0
) < op_prio (node
))
1999 pp_right_paren (buffer
);
2002 case VIEW_CONVERT_EXPR
:
2003 pp_string (buffer
, "VIEW_CONVERT_EXPR<");
2004 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
2005 pp_string (buffer
, ">(");
2006 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2007 pp_right_paren (buffer
);
2011 pp_string (buffer
, "((");
2012 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2013 pp_string (buffer
, "))");
2016 case NON_LVALUE_EXPR
:
2017 pp_string (buffer
, "NON_LVALUE_EXPR <");
2018 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2019 pp_greater (buffer
);
2023 pp_string (buffer
, "SAVE_EXPR <");
2024 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2025 pp_greater (buffer
);
2029 pp_string (buffer
, "COMPLEX_EXPR <");
2030 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2031 pp_string (buffer
, ", ");
2032 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2033 pp_greater (buffer
);
2037 pp_string (buffer
, "CONJ_EXPR <");
2038 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2039 pp_greater (buffer
);
2043 pp_string (buffer
, "REALPART_EXPR <");
2044 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2045 pp_greater (buffer
);
2049 pp_string (buffer
, "IMAGPART_EXPR <");
2050 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2051 pp_greater (buffer
);
2055 pp_string (buffer
, "VA_ARG_EXPR <");
2056 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2057 pp_greater (buffer
);
2060 case TRY_FINALLY_EXPR
:
2061 case TRY_CATCH_EXPR
:
2062 pp_string (buffer
, "try");
2063 newline_and_indent (buffer
, spc
+2);
2064 pp_left_brace (buffer
);
2065 newline_and_indent (buffer
, spc
+4);
2066 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2067 newline_and_indent (buffer
, spc
+2);
2068 pp_right_brace (buffer
);
2069 newline_and_indent (buffer
, spc
);
2071 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2072 newline_and_indent (buffer
, spc
+2);
2073 pp_left_brace (buffer
);
2074 newline_and_indent (buffer
, spc
+4);
2075 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2076 newline_and_indent (buffer
, spc
+2);
2077 pp_right_brace (buffer
);
2082 pp_string (buffer
, "catch (");
2083 dump_generic_node (buffer
, CATCH_TYPES (node
), spc
+2, flags
, false);
2084 pp_right_paren (buffer
);
2085 newline_and_indent (buffer
, spc
+2);
2086 pp_left_brace (buffer
);
2087 newline_and_indent (buffer
, spc
+4);
2088 dump_generic_node (buffer
, CATCH_BODY (node
), spc
+4, flags
, true);
2089 newline_and_indent (buffer
, spc
+2);
2090 pp_right_brace (buffer
);
2094 case EH_FILTER_EXPR
:
2095 pp_string (buffer
, "<<<eh_filter (");
2096 dump_generic_node (buffer
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2097 pp_string (buffer
, ")>>>");
2098 newline_and_indent (buffer
, spc
+2);
2099 pp_left_brace (buffer
);
2100 newline_and_indent (buffer
, spc
+4);
2101 dump_generic_node (buffer
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2102 newline_and_indent (buffer
, spc
+2);
2103 pp_right_brace (buffer
);
2108 op0
= TREE_OPERAND (node
, 0);
2109 /* If this is for break or continue, don't bother printing it. */
2110 if (DECL_NAME (op0
))
2112 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2113 if (strcmp (name
, "break") == 0
2114 || strcmp (name
, "continue") == 0)
2117 dump_generic_node (buffer
, op0
, spc
, flags
, false);
2119 if (DECL_NONLOCAL (op0
))
2120 pp_string (buffer
, " [non-local]");
2124 pp_string (buffer
, "while (1)");
2125 if (!(flags
& TDF_SLIM
))
2127 newline_and_indent (buffer
, spc
+2);
2128 pp_left_brace (buffer
);
2129 newline_and_indent (buffer
, spc
+4);
2130 dump_generic_node (buffer
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2131 newline_and_indent (buffer
, spc
+2);
2132 pp_right_brace (buffer
);
2138 pp_string (buffer
, "// predicted ");
2139 if (PREDICT_EXPR_OUTCOME (node
))
2140 pp_string (buffer
, "likely by ");
2142 pp_string (buffer
, "unlikely by ");
2143 pp_string (buffer
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2144 pp_string (buffer
, " predictor.");
2148 pp_string (buffer
, "ANNOTATE_EXPR <");
2149 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2150 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2152 case annot_expr_ivdep_kind
:
2153 pp_string (buffer
, ", ivdep");
2155 case annot_expr_no_vector_kind
:
2156 pp_string (buffer
, ", no-vector");
2158 case annot_expr_vector_kind
:
2159 pp_string (buffer
, ", vector");
2164 pp_greater (buffer
);
2168 pp_string (buffer
, "return");
2169 op0
= TREE_OPERAND (node
, 0);
2173 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2174 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1),
2177 dump_generic_node (buffer
, op0
, spc
, flags
, false);
2182 pp_string (buffer
, "if (");
2183 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2184 pp_string (buffer
, ") break");
2188 pp_string (buffer
, "switch (");
2189 dump_generic_node (buffer
, SWITCH_COND (node
), spc
, flags
, false);
2190 pp_right_paren (buffer
);
2191 if (!(flags
& TDF_SLIM
))
2193 newline_and_indent (buffer
, spc
+2);
2194 pp_left_brace (buffer
);
2195 if (SWITCH_BODY (node
))
2197 newline_and_indent (buffer
, spc
+4);
2198 dump_generic_node (buffer
, SWITCH_BODY (node
), spc
+4, flags
,
2203 tree vec
= SWITCH_LABELS (node
);
2204 size_t i
, n
= TREE_VEC_LENGTH (vec
);
2205 for (i
= 0; i
< n
; ++i
)
2207 tree elt
= TREE_VEC_ELT (vec
, i
);
2208 newline_and_indent (buffer
, spc
+4);
2211 dump_generic_node (buffer
, elt
, spc
+4, flags
, false);
2212 pp_string (buffer
, " goto ");
2213 dump_generic_node (buffer
, CASE_LABEL (elt
), spc
+4,
2215 pp_semicolon (buffer
);
2218 pp_string (buffer
, "case ???: goto ???;");
2221 newline_and_indent (buffer
, spc
+2);
2222 pp_right_brace (buffer
);
2228 op0
= GOTO_DESTINATION (node
);
2229 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2231 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2232 if (strcmp (name
, "break") == 0
2233 || strcmp (name
, "continue") == 0)
2235 pp_string (buffer
, name
);
2239 pp_string (buffer
, "goto ");
2240 dump_generic_node (buffer
, op0
, spc
, flags
, false);
2244 pp_string (buffer
, "__asm__");
2245 if (ASM_VOLATILE_P (node
))
2246 pp_string (buffer
, " __volatile__");
2247 pp_left_paren (buffer
);
2248 dump_generic_node (buffer
, ASM_STRING (node
), spc
, flags
, false);
2250 dump_generic_node (buffer
, ASM_OUTPUTS (node
), spc
, flags
, false);
2252 dump_generic_node (buffer
, ASM_INPUTS (node
), spc
, flags
, false);
2253 if (ASM_CLOBBERS (node
))
2256 dump_generic_node (buffer
, ASM_CLOBBERS (node
), spc
, flags
, false);
2258 pp_right_paren (buffer
);
2261 case CASE_LABEL_EXPR
:
2262 if (CASE_LOW (node
) && CASE_HIGH (node
))
2264 pp_string (buffer
, "case ");
2265 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
2266 pp_string (buffer
, " ... ");
2267 dump_generic_node (buffer
, CASE_HIGH (node
), spc
, flags
, false);
2269 else if (CASE_LOW (node
))
2271 pp_string (buffer
, "case ");
2272 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
2275 pp_string (buffer
, "default");
2280 pp_string (buffer
, "OBJ_TYPE_REF(");
2281 dump_generic_node (buffer
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2282 pp_semicolon (buffer
);
2283 if (!(flags
& TDF_SLIM
) && virtual_method_call_p (node
))
2285 pp_string (buffer
, "(");
2286 dump_generic_node (buffer
, obj_type_ref_class (node
), spc
, flags
, false);
2287 pp_string (buffer
, ")");
2289 dump_generic_node (buffer
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2291 dump_generic_node (buffer
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2292 pp_right_paren (buffer
);
2296 if (SSA_NAME_IDENTIFIER (node
))
2297 dump_generic_node (buffer
, SSA_NAME_IDENTIFIER (node
),
2299 pp_underscore (buffer
);
2300 pp_decimal_int (buffer
, SSA_NAME_VERSION (node
));
2301 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2302 pp_string (buffer
, "(D)");
2303 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2304 pp_string (buffer
, "(ab)");
2307 case WITH_SIZE_EXPR
:
2308 pp_string (buffer
, "WITH_SIZE_EXPR <");
2309 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2310 pp_string (buffer
, ", ");
2311 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2312 pp_greater (buffer
);
2316 pp_string (buffer
, "ASSERT_EXPR <");
2317 dump_generic_node (buffer
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2318 pp_string (buffer
, ", ");
2319 dump_generic_node (buffer
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2320 pp_greater (buffer
);
2324 pp_string (buffer
, "scev_known");
2327 case SCEV_NOT_KNOWN
:
2328 pp_string (buffer
, "scev_not_known");
2331 case POLYNOMIAL_CHREC
:
2332 pp_left_brace (buffer
);
2333 dump_generic_node (buffer
, CHREC_LEFT (node
), spc
, flags
, false);
2334 pp_string (buffer
, ", +, ");
2335 dump_generic_node (buffer
, CHREC_RIGHT (node
), spc
, flags
, false);
2336 pp_string (buffer
, "}_");
2337 dump_generic_node (buffer
, CHREC_VAR (node
), spc
, flags
, false);
2341 case REALIGN_LOAD_EXPR
:
2342 pp_string (buffer
, "REALIGN_LOAD <");
2343 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2344 pp_string (buffer
, ", ");
2345 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2346 pp_string (buffer
, ", ");
2347 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2348 pp_greater (buffer
);
2352 pp_string (buffer
, " VEC_COND_EXPR < ");
2353 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2354 pp_string (buffer
, " , ");
2355 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2356 pp_string (buffer
, " , ");
2357 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2358 pp_string (buffer
, " > ");
2362 pp_string (buffer
, " VEC_PERM_EXPR < ");
2363 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2364 pp_string (buffer
, " , ");
2365 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2366 pp_string (buffer
, " , ");
2367 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2368 pp_string (buffer
, " > ");
2372 pp_string (buffer
, " DOT_PROD_EXPR < ");
2373 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2374 pp_string (buffer
, ", ");
2375 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2376 pp_string (buffer
, ", ");
2377 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2378 pp_string (buffer
, " > ");
2381 case WIDEN_MULT_PLUS_EXPR
:
2382 pp_string (buffer
, " WIDEN_MULT_PLUS_EXPR < ");
2383 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2384 pp_string (buffer
, ", ");
2385 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2386 pp_string (buffer
, ", ");
2387 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2388 pp_string (buffer
, " > ");
2391 case WIDEN_MULT_MINUS_EXPR
:
2392 pp_string (buffer
, " WIDEN_MULT_MINUS_EXPR < ");
2393 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2394 pp_string (buffer
, ", ");
2395 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2396 pp_string (buffer
, ", ");
2397 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2398 pp_string (buffer
, " > ");
2402 pp_string (buffer
, " FMA_EXPR < ");
2403 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2404 pp_string (buffer
, ", ");
2405 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2406 pp_string (buffer
, ", ");
2407 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2408 pp_string (buffer
, " > ");
2412 pp_string (buffer
, "#pragma omp parallel");
2413 dump_omp_clauses (buffer
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2416 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2418 newline_and_indent (buffer
, spc
+ 2);
2419 pp_left_brace (buffer
);
2420 newline_and_indent (buffer
, spc
+ 4);
2421 dump_generic_node (buffer
, OMP_BODY (node
), spc
+ 4, flags
, false);
2422 newline_and_indent (buffer
, spc
+ 2);
2423 pp_right_brace (buffer
);
2429 pp_string (buffer
, "#pragma omp task");
2430 dump_omp_clauses (buffer
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2434 pp_string (buffer
, "#pragma omp for");
2438 pp_string (buffer
, "#pragma omp simd");
2442 pp_string (buffer
, "#pragma simd");
2446 /* This label points one line after dumping the clauses.
2447 For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2448 parameters are printed out. */
2449 goto dump_omp_loop_cilk_for
;
2451 case OMP_DISTRIBUTE
:
2452 pp_string (buffer
, "#pragma omp distribute");
2456 pp_string (buffer
, "#pragma omp teams");
2457 dump_omp_clauses (buffer
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
2460 case OMP_TARGET_DATA
:
2461 pp_string (buffer
, "#pragma omp target data");
2462 dump_omp_clauses (buffer
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
2466 pp_string (buffer
, "#pragma omp target");
2467 dump_omp_clauses (buffer
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
2470 case OMP_TARGET_UPDATE
:
2471 pp_string (buffer
, "#pragma omp target update");
2472 dump_omp_clauses (buffer
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
2477 dump_omp_clauses (buffer
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2479 dump_omp_loop_cilk_for
:
2480 if (!(flags
& TDF_SLIM
))
2484 if (OMP_FOR_PRE_BODY (node
))
2486 if (TREE_CODE (node
) == CILK_FOR
)
2487 pp_string (buffer
, " ");
2489 newline_and_indent (buffer
, spc
+ 2);
2490 pp_left_brace (buffer
);
2492 newline_and_indent (buffer
, spc
);
2493 dump_generic_node (buffer
, OMP_FOR_PRE_BODY (node
),
2496 if (OMP_FOR_INIT (node
))
2499 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
2502 if (TREE_CODE (node
) != CILK_FOR
|| OMP_FOR_PRE_BODY (node
))
2503 newline_and_indent (buffer
, spc
);
2504 if (TREE_CODE (node
) == CILK_FOR
)
2505 pp_string (buffer
, "_Cilk_for (");
2507 pp_string (buffer
, "for (");
2508 dump_generic_node (buffer
,
2509 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
2511 pp_string (buffer
, "; ");
2512 dump_generic_node (buffer
,
2513 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
2515 pp_string (buffer
, "; ");
2516 dump_generic_node (buffer
,
2517 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
2519 pp_right_paren (buffer
);
2521 if (TREE_CODE (node
) == CILK_FOR
)
2522 dump_omp_clauses (buffer
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2524 if (OMP_FOR_BODY (node
))
2526 newline_and_indent (buffer
, spc
+ 2);
2527 pp_left_brace (buffer
);
2528 newline_and_indent (buffer
, spc
+ 4);
2529 dump_generic_node (buffer
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
2531 newline_and_indent (buffer
, spc
+ 2);
2532 pp_right_brace (buffer
);
2534 if (OMP_FOR_INIT (node
))
2535 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
2536 if (OMP_FOR_PRE_BODY (node
))
2539 newline_and_indent (buffer
, spc
+ 2);
2540 pp_right_brace (buffer
);
2547 pp_string (buffer
, "#pragma omp sections");
2548 dump_omp_clauses (buffer
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
2552 pp_string (buffer
, "#pragma omp section");
2556 pp_string (buffer
, "#pragma omp master");
2560 pp_string (buffer
, "#pragma omp taskgroup");
2564 pp_string (buffer
, "#pragma omp ordered");
2568 pp_string (buffer
, "#pragma omp critical");
2569 if (OMP_CRITICAL_NAME (node
))
2572 pp_left_paren (buffer
);
2573 dump_generic_node (buffer
, OMP_CRITICAL_NAME (node
), spc
,
2575 pp_right_paren (buffer
);
2580 pp_string (buffer
, "#pragma omp atomic");
2581 if (OMP_ATOMIC_SEQ_CST (node
))
2582 pp_string (buffer
, " seq_cst");
2583 newline_and_indent (buffer
, spc
+ 2);
2584 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2588 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2591 case OMP_ATOMIC_READ
:
2592 pp_string (buffer
, "#pragma omp atomic read");
2593 if (OMP_ATOMIC_SEQ_CST (node
))
2594 pp_string (buffer
, " seq_cst");
2595 newline_and_indent (buffer
, spc
+ 2);
2596 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2600 case OMP_ATOMIC_CAPTURE_OLD
:
2601 case OMP_ATOMIC_CAPTURE_NEW
:
2602 pp_string (buffer
, "#pragma omp atomic capture");
2603 if (OMP_ATOMIC_SEQ_CST (node
))
2604 pp_string (buffer
, " seq_cst");
2605 newline_and_indent (buffer
, spc
+ 2);
2606 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2610 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2614 pp_string (buffer
, "#pragma omp single");
2615 dump_omp_clauses (buffer
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
2619 dump_omp_clause (buffer
, node
, spc
, flags
);
2623 case TRANSACTION_EXPR
:
2624 if (TRANSACTION_EXPR_OUTER (node
))
2625 pp_string (buffer
, "__transaction_atomic [[outer]]");
2626 else if (TRANSACTION_EXPR_RELAXED (node
))
2627 pp_string (buffer
, "__transaction_relaxed");
2629 pp_string (buffer
, "__transaction_atomic");
2630 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
2632 newline_and_indent (buffer
, spc
);
2633 pp_left_brace (buffer
);
2634 newline_and_indent (buffer
, spc
+ 2);
2635 dump_generic_node (buffer
, TRANSACTION_EXPR_BODY (node
),
2636 spc
+ 2, flags
, false);
2637 newline_and_indent (buffer
, spc
);
2638 pp_right_brace (buffer
);
2643 case REDUC_MAX_EXPR
:
2644 pp_string (buffer
, " REDUC_MAX_EXPR < ");
2645 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2646 pp_string (buffer
, " > ");
2649 case REDUC_MIN_EXPR
:
2650 pp_string (buffer
, " REDUC_MIN_EXPR < ");
2651 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2652 pp_string (buffer
, " > ");
2655 case REDUC_PLUS_EXPR
:
2656 pp_string (buffer
, " REDUC_PLUS_EXPR < ");
2657 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2658 pp_string (buffer
, " > ");
2661 case VEC_WIDEN_MULT_HI_EXPR
:
2662 case VEC_WIDEN_MULT_LO_EXPR
:
2663 case VEC_WIDEN_MULT_EVEN_EXPR
:
2664 case VEC_WIDEN_MULT_ODD_EXPR
:
2665 case VEC_WIDEN_LSHIFT_HI_EXPR
:
2666 case VEC_WIDEN_LSHIFT_LO_EXPR
:
2668 for (str
= get_tree_code_name (code
); *str
; str
++)
2669 pp_character (buffer
, TOUPPER (*str
));
2670 pp_string (buffer
, " < ");
2671 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2672 pp_string (buffer
, ", ");
2673 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2674 pp_string (buffer
, " > ");
2677 case VEC_UNPACK_HI_EXPR
:
2678 pp_string (buffer
, " VEC_UNPACK_HI_EXPR < ");
2679 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2680 pp_string (buffer
, " > ");
2683 case VEC_UNPACK_LO_EXPR
:
2684 pp_string (buffer
, " VEC_UNPACK_LO_EXPR < ");
2685 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2686 pp_string (buffer
, " > ");
2689 case VEC_UNPACK_FLOAT_HI_EXPR
:
2690 pp_string (buffer
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2691 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2692 pp_string (buffer
, " > ");
2695 case VEC_UNPACK_FLOAT_LO_EXPR
:
2696 pp_string (buffer
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2697 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2698 pp_string (buffer
, " > ");
2701 case VEC_PACK_TRUNC_EXPR
:
2702 pp_string (buffer
, " VEC_PACK_TRUNC_EXPR < ");
2703 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2704 pp_string (buffer
, ", ");
2705 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2706 pp_string (buffer
, " > ");
2709 case VEC_PACK_SAT_EXPR
:
2710 pp_string (buffer
, " VEC_PACK_SAT_EXPR < ");
2711 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2712 pp_string (buffer
, ", ");
2713 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2714 pp_string (buffer
, " > ");
2717 case VEC_PACK_FIX_TRUNC_EXPR
:
2718 pp_string (buffer
, " VEC_PACK_FIX_TRUNC_EXPR < ");
2719 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2720 pp_string (buffer
, ", ");
2721 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2722 pp_string (buffer
, " > ");
2726 dump_block_node (buffer
, node
, spc
, flags
);
2729 case CILK_SPAWN_STMT
:
2730 pp_string (buffer
, "_Cilk_spawn ");
2731 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2734 case CILK_SYNC_STMT
:
2735 pp_string (buffer
, "_Cilk_sync");
2742 if (is_stmt
&& is_expr
)
2743 pp_semicolon (buffer
);
2748 /* Print the declaration of a variable. */
2751 print_declaration (pretty_printer
*buffer
, tree t
, int spc
, int flags
)
2755 if (TREE_CODE(t
) == NAMELIST_DECL
)
2757 pp_string(buffer
, "namelist ");
2758 dump_decl_name (buffer
, t
, flags
);
2759 pp_semicolon (buffer
);
2763 if (TREE_CODE (t
) == TYPE_DECL
)
2764 pp_string (buffer
, "typedef ");
2766 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
2767 pp_string (buffer
, "register ");
2769 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
2770 pp_string (buffer
, "extern ");
2771 else if (TREE_STATIC (t
))
2772 pp_string (buffer
, "static ");
2774 /* Print the type and name. */
2775 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
2779 /* Print array's type. */
2780 tmp
= TREE_TYPE (t
);
2781 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
2782 tmp
= TREE_TYPE (tmp
);
2783 dump_generic_node (buffer
, TREE_TYPE (tmp
), spc
, flags
, false);
2785 /* Print variable's name. */
2787 dump_generic_node (buffer
, t
, spc
, flags
, false);
2789 /* Print the dimensions. */
2790 tmp
= TREE_TYPE (t
);
2791 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
2793 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
2794 tmp
= TREE_TYPE (tmp
);
2797 else if (TREE_CODE (t
) == FUNCTION_DECL
)
2799 dump_generic_node (buffer
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
2801 dump_decl_name (buffer
, t
, flags
);
2802 dump_function_declaration (buffer
, TREE_TYPE (t
), spc
, flags
);
2806 /* Print type declaration. */
2807 dump_generic_node (buffer
, TREE_TYPE (t
), spc
, flags
, false);
2809 /* Print variable's name. */
2811 dump_generic_node (buffer
, t
, spc
, flags
, false);
2814 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
2816 pp_string (buffer
, " __asm__ ");
2817 pp_left_paren (buffer
);
2818 dump_generic_node (buffer
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
2819 pp_right_paren (buffer
);
2822 /* The initial value of a function serves to determine whether the function
2823 is declared or defined. So the following does not apply to function
2825 if (TREE_CODE (t
) != FUNCTION_DECL
)
2827 /* Print the initial value. */
2828 if (DECL_INITIAL (t
))
2833 dump_generic_node (buffer
, DECL_INITIAL (t
), spc
, flags
, false);
2837 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
2839 pp_string (buffer
, " [value-expr: ");
2840 dump_generic_node (buffer
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
2841 pp_right_bracket (buffer
);
2844 pp_semicolon (buffer
);
2848 /* Prints a structure: name, fields, and methods.
2849 FIXME: Still incomplete. */
2852 print_struct_decl (pretty_printer
*buffer
, const_tree node
, int spc
, int flags
)
2854 /* Print the name of the structure. */
2855 if (TYPE_NAME (node
))
2858 if (TREE_CODE (node
) == RECORD_TYPE
)
2859 pp_string (buffer
, "struct ");
2860 else if ((TREE_CODE (node
) == UNION_TYPE
2861 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
2862 pp_string (buffer
, "union ");
2864 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, 0, false);
2867 /* Print the contents of the structure. */
2868 pp_newline (buffer
);
2870 pp_left_brace (buffer
);
2871 pp_newline (buffer
);
2873 /* Print the fields of the structure. */
2876 tmp
= TYPE_FIELDS (node
);
2879 /* Avoid to print recursively the structure. */
2880 /* FIXME : Not implemented correctly...,
2881 what about the case when we have a cycle in the contain graph? ...
2882 Maybe this could be solved by looking at the scope in which the
2883 structure was declared. */
2884 if (TREE_TYPE (tmp
) != node
2885 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
2886 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
2888 print_declaration (buffer
, tmp
, spc
+2, flags
);
2889 pp_newline (buffer
);
2891 tmp
= DECL_CHAIN (tmp
);
2895 pp_right_brace (buffer
);
2898 /* Return the priority of the operator CODE.
2900 From lowest to highest precedence with either left-to-right (L-R)
2901 or right-to-left (R-L) associativity]:
2904 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2916 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2917 15 [L-R] fn() [] -> .
2919 unary +, - and * have higher precedence than the corresponding binary
2923 op_code_prio (enum tree_code code
)
2940 case TRUTH_ORIF_EXPR
:
2943 case TRUTH_AND_EXPR
:
2944 case TRUTH_ANDIF_EXPR
:
2951 case TRUTH_XOR_EXPR
:
2968 case UNORDERED_EXPR
:
2979 case VEC_WIDEN_LSHIFT_HI_EXPR
:
2980 case VEC_WIDEN_LSHIFT_LO_EXPR
:
2981 case WIDEN_LSHIFT_EXPR
:
2984 case WIDEN_SUM_EXPR
:
2986 case POINTER_PLUS_EXPR
:
2990 case VEC_WIDEN_MULT_HI_EXPR
:
2991 case VEC_WIDEN_MULT_LO_EXPR
:
2992 case WIDEN_MULT_EXPR
:
2994 case WIDEN_MULT_PLUS_EXPR
:
2995 case WIDEN_MULT_MINUS_EXPR
:
2997 case MULT_HIGHPART_EXPR
:
2998 case TRUNC_DIV_EXPR
:
3000 case FLOOR_DIV_EXPR
:
3001 case ROUND_DIV_EXPR
:
3003 case EXACT_DIV_EXPR
:
3004 case TRUNC_MOD_EXPR
:
3006 case FLOOR_MOD_EXPR
:
3007 case ROUND_MOD_EXPR
:
3011 case TRUTH_NOT_EXPR
:
3013 case POSTINCREMENT_EXPR
:
3014 case POSTDECREMENT_EXPR
:
3015 case PREINCREMENT_EXPR
:
3016 case PREDECREMENT_EXPR
:
3022 case FIX_TRUNC_EXPR
:
3028 case ARRAY_RANGE_REF
:
3032 /* Special expressions. */
3038 case REDUC_MAX_EXPR
:
3039 case REDUC_MIN_EXPR
:
3040 case REDUC_PLUS_EXPR
:
3041 case VEC_RSHIFT_EXPR
:
3042 case VEC_UNPACK_HI_EXPR
:
3043 case VEC_UNPACK_LO_EXPR
:
3044 case VEC_UNPACK_FLOAT_HI_EXPR
:
3045 case VEC_UNPACK_FLOAT_LO_EXPR
:
3046 case VEC_PACK_TRUNC_EXPR
:
3047 case VEC_PACK_SAT_EXPR
:
3051 /* Return an arbitrarily high precedence to avoid surrounding single
3052 VAR_DECLs in ()s. */
3057 /* Return the priority of the operator OP. */
3060 op_prio (const_tree op
)
3062 enum tree_code code
;
3067 code
= TREE_CODE (op
);
3068 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3069 return op_prio (TREE_OPERAND (op
, 0));
3071 return op_code_prio (code
);
3074 /* Return the symbol associated with operator CODE. */
3077 op_symbol_code (enum tree_code code
)
3085 case TRUTH_ORIF_EXPR
:
3088 case TRUTH_AND_EXPR
:
3089 case TRUTH_ANDIF_EXPR
:
3095 case TRUTH_XOR_EXPR
:
3105 case UNORDERED_EXPR
:
3151 case VEC_RSHIFT_EXPR
:
3154 case WIDEN_LSHIFT_EXPR
:
3157 case POINTER_PLUS_EXPR
:
3163 case REDUC_PLUS_EXPR
:
3166 case WIDEN_SUM_EXPR
:
3169 case WIDEN_MULT_EXPR
:
3172 case MULT_HIGHPART_EXPR
:
3182 case TRUTH_NOT_EXPR
:
3189 case TRUNC_DIV_EXPR
:
3196 case FLOOR_DIV_EXPR
:
3199 case ROUND_DIV_EXPR
:
3202 case EXACT_DIV_EXPR
:
3205 case TRUNC_MOD_EXPR
:
3211 case FLOOR_MOD_EXPR
:
3214 case ROUND_MOD_EXPR
:
3217 case PREDECREMENT_EXPR
:
3220 case PREINCREMENT_EXPR
:
3223 case POSTDECREMENT_EXPR
:
3226 case POSTINCREMENT_EXPR
:
3236 return "<<< ??? >>>";
3240 /* Return the symbol associated with operator OP. */
3243 op_symbol (const_tree op
)
3245 return op_symbol_code (TREE_CODE (op
));
3248 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3249 the gimple_call_fn of a GIMPLE_CALL. */
3252 print_call_name (pretty_printer
*buffer
, tree node
, int flags
)
3256 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3257 op0
= TREE_OPERAND (op0
, 0);
3260 switch (TREE_CODE (op0
))
3265 dump_function_name (buffer
, op0
, flags
);
3271 op0
= TREE_OPERAND (op0
, 0);
3275 pp_left_paren (buffer
);
3276 dump_generic_node (buffer
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3277 pp_string (buffer
, ") ? ");
3278 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3279 pp_string (buffer
, " : ");
3280 dump_generic_node (buffer
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3284 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3285 dump_function_name (buffer
, TREE_OPERAND (op0
, 0), flags
);
3287 dump_generic_node (buffer
, op0
, 0, flags
, false);
3291 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3293 op0
= TREE_OPERAND (op0
, 0);
3300 dump_generic_node (buffer
, op0
, 0, flags
, false);
3308 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3311 pretty_print_string (pretty_printer
*buffer
, const char *str
)
3321 pp_string (buffer
, "\\b");
3325 pp_string (buffer
, "\\f");
3329 pp_string (buffer
, "\\n");
3333 pp_string (buffer
, "\\r");
3337 pp_string (buffer
, "\\t");
3341 pp_string (buffer
, "\\v");
3345 pp_string (buffer
, "\\\\");
3349 pp_string (buffer
, "\\\"");
3353 pp_string (buffer
, "\\'");
3356 /* No need to handle \0; the loop terminates on \0. */
3359 pp_string (buffer
, "\\1");
3363 pp_string (buffer
, "\\2");
3367 pp_string (buffer
, "\\3");
3371 pp_string (buffer
, "\\4");
3375 pp_string (buffer
, "\\5");
3379 pp_string (buffer
, "\\6");
3383 pp_string (buffer
, "\\7");
3387 pp_character (buffer
, str
[0]);
3395 maybe_init_pretty_print (FILE *file
)
3399 new (&buffer
) pretty_printer ();
3400 pp_needs_newline (&buffer
) = true;
3401 pp_translate_identifiers (&buffer
) = false;
3405 buffer
.buffer
->stream
= file
;
3409 newline_and_indent (pretty_printer
*buffer
, int spc
)
3411 pp_newline (buffer
);
3415 /* Handle a %K format for TEXT. Separate from default_tree_printer so
3416 it can also be used in front ends.
3417 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3421 percent_K_format (text_info
*text
)
3423 tree t
= va_arg (*text
->args_ptr
, tree
), block
;
3424 gcc_assert (text
->locus
!= NULL
);
3425 *text
->locus
= EXPR_LOCATION (t
);
3426 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3427 block
= TREE_BLOCK (t
);
3428 *pp_ti_abstract_origin (text
) = NULL
;
3432 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3433 representing the outermost block of an inlined function.
3434 So walk the BLOCK tree until we hit such a scope. */
3436 && TREE_CODE (block
) == BLOCK
)
3438 if (inlined_function_outer_scope_p (block
))
3440 *pp_ti_abstract_origin (text
) = block
;
3443 block
= BLOCK_SUPERCONTEXT (block
);
3449 && TREE_CODE (block
) == BLOCK
3450 && BLOCK_ABSTRACT_ORIGIN (block
))
3452 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3454 while (TREE_CODE (ao
) == BLOCK
3455 && BLOCK_ABSTRACT_ORIGIN (ao
)
3456 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3457 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3459 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3461 *pp_ti_abstract_origin (text
) = block
;
3464 block
= BLOCK_SUPERCONTEXT (block
);
3468 /* Print the identifier ID to PRETTY-PRINTER. */
3471 pp_tree_identifier (pretty_printer
*pp
, tree id
)
3473 if (pp_translate_identifiers (pp
))
3475 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
3476 pp_append_text (pp
, text
, text
+ strlen (text
));
3479 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
3480 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
3483 /* A helper function that is used to dump function information before the
3487 dump_function_header (FILE *dump_file
, tree fdecl
, int flags
)
3489 const char *dname
, *aname
;
3490 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
3491 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
3493 dname
= lang_hooks
.decl_printable_name (fdecl
, 2);
3495 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
3496 aname
= (IDENTIFIER_POINTER
3497 (DECL_ASSEMBLER_NAME (fdecl
)));
3499 aname
= "<unset-asm-name>";
3501 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
3502 dname
, aname
, fun
->funcdef_no
);
3503 if (!(flags
& TDF_NOUID
))
3504 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
3507 fprintf (dump_file
, ", cgraph_uid=%d", node
->uid
);
3508 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
3509 node
->frequency
== NODE_FREQUENCY_HOT
3511 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
3512 ? " (unlikely executed)"
3513 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
3514 ? " (executed once)"
3518 fprintf (dump_file
, ")\n\n");
3521 /* Dump double_int D to pretty_printer PP. UNS is true
3522 if D is unsigned and false otherwise. */
3524 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
3527 pp_wide_integer (pp
, d
.low
);
3528 else if (d
.fits_uhwi ())
3529 pp_unsigned_wide_integer (pp
, d
.low
);
3532 unsigned HOST_WIDE_INT low
= d
.low
;
3533 HOST_WIDE_INT high
= d
.high
;
3534 if (!uns
&& d
.is_negative ())
3537 high
= ~high
+ !low
;
3540 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
3542 sprintf (pp_buffer (pp
)->digit_buffer
,
3543 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
3544 (unsigned HOST_WIDE_INT
) high
, low
);
3545 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);