1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2015 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"
27 #include "gimple-expr.h"
30 #include "insn-config.h"
33 #include "tree-pretty-print.h"
35 #include "stor-layout.h"
43 #include "langhooks.h"
44 #include "tree-iterator.h"
45 #include "tree-chrec.h"
47 #include "value-prof.h"
48 #include "internal-fn.h"
49 #include "gomp-constants.h"
51 /* Local functions, macros and variables. */
52 static const char *op_symbol (const_tree
);
53 static void pretty_print_string (pretty_printer
*, const char*);
54 static void newline_and_indent (pretty_printer
*, int);
55 static void maybe_init_pretty_print (FILE *);
56 static void print_struct_decl (pretty_printer
*, const_tree
, int, int);
57 static void do_niy (pretty_printer
*, const_tree
);
59 #define INDENT(SPACE) do { \
60 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
62 #define NIY do_niy (pp, node)
64 static pretty_printer
*tree_pp
;
66 /* Try to print something for an unknown tree code. */
69 do_niy (pretty_printer
*pp
, const_tree node
)
73 pp_string (pp
, "<<< Unknown tree: ");
74 pp_string (pp
, get_tree_code_name (TREE_CODE (node
)));
78 len
= TREE_OPERAND_LENGTH (node
);
79 for (i
= 0; i
< len
; ++i
)
81 newline_and_indent (pp
, 2);
82 dump_generic_node (pp
, TREE_OPERAND (node
, i
), 2, 0, false);
86 pp_string (pp
, " >>>");
89 /* Debugging function to print out a generic expression. */
92 debug_generic_expr (tree t
)
94 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
95 fprintf (stderr
, "\n");
98 /* Debugging function to print out a generic statement. */
101 debug_generic_stmt (tree t
)
103 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
104 fprintf (stderr
, "\n");
107 /* Debugging function to print out a chain of trees . */
110 debug_tree_chain (tree t
)
116 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
117 fprintf (stderr
, " ");
121 fprintf (stderr
, "... [cycled back to ");
122 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
123 fprintf (stderr
, "]");
127 fprintf (stderr
, "\n");
130 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
132 print_generic_decl (FILE *file
, tree decl
, int flags
)
134 maybe_init_pretty_print (file
);
135 print_declaration (tree_pp
, decl
, 2, flags
);
136 pp_write_text_to_stream (tree_pp
);
139 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
140 to show in the dump. See TDF_* in dumpfile.h. */
143 print_generic_stmt (FILE *file
, tree t
, int flags
)
145 maybe_init_pretty_print (file
);
146 dump_generic_node (tree_pp
, t
, 0, flags
, true);
147 pp_newline_and_flush (tree_pp
);
150 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
151 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
155 print_generic_stmt_indented (FILE *file
, tree t
, int flags
, int indent
)
159 maybe_init_pretty_print (file
);
161 for (i
= 0; i
< indent
; i
++)
163 dump_generic_node (tree_pp
, t
, indent
, flags
, true);
164 pp_newline_and_flush (tree_pp
);
167 /* Print a single expression T on file FILE. FLAGS specifies details to show
168 in the dump. See TDF_* in dumpfile.h. */
171 print_generic_expr (FILE *file
, tree t
, int flags
)
173 maybe_init_pretty_print (file
);
174 dump_generic_node (tree_pp
, t
, 0, flags
, false);
178 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
182 dump_decl_name (pretty_printer
*pp
, tree node
, int flags
)
184 if (DECL_NAME (node
))
186 if ((flags
& TDF_ASMNAME
) && DECL_ASSEMBLER_NAME_SET_P (node
))
187 pp_tree_identifier (pp
, DECL_ASSEMBLER_NAME (node
));
189 pp_tree_identifier (pp
, DECL_NAME (node
));
191 if ((flags
& TDF_UID
) || DECL_NAME (node
) == NULL_TREE
)
193 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
194 pp_printf (pp
, "L.%d", (int) LABEL_DECL_UID (node
));
195 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
197 if (flags
& TDF_NOUID
)
198 pp_string (pp
, "D#xxxx");
200 pp_printf (pp
, "D#%i", DEBUG_TEMP_UID (node
));
204 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
205 if (flags
& TDF_NOUID
)
206 pp_printf (pp
, "%c.xxxx", c
);
208 pp_printf (pp
, "%c.%u", c
, DECL_UID (node
));
211 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
213 if (flags
& TDF_NOUID
)
214 pp_printf (pp
, "ptD.xxxx");
216 pp_printf (pp
, "ptD.%u", DECL_PT_UID (node
));
220 /* Like the above, but used for pretty printing function calls. */
223 dump_function_name (pretty_printer
*pp
, tree node
, int flags
)
225 if (CONVERT_EXPR_P (node
))
226 node
= TREE_OPERAND (node
, 0);
227 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
228 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
230 dump_decl_name (pp
, node
, flags
);
233 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
234 FLAGS are as in dump_generic_node. */
237 dump_function_declaration (pretty_printer
*pp
, tree node
,
240 bool wrote_arg
= false;
246 /* Print the argument types. */
247 arg
= TYPE_ARG_TYPES (node
);
248 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
256 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
257 arg
= TREE_CHAIN (arg
);
260 /* Drop the trailing void_type_node if we had any previous argument. */
261 if (arg
== void_list_node
&& !wrote_arg
)
262 pp_string (pp
, "void");
263 /* Properly dump vararg function types. */
264 else if (!arg
&& wrote_arg
)
265 pp_string (pp
, ", ...");
266 /* Avoid printing any arg for unprototyped functions. */
271 /* Dump the domain associated with an array. */
274 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, int flags
)
276 pp_left_bracket (pp
);
279 tree min
= TYPE_MIN_VALUE (domain
);
280 tree max
= TYPE_MAX_VALUE (domain
);
283 && integer_zerop (min
)
284 && tree_fits_shwi_p (max
))
285 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
289 dump_generic_node (pp
, min
, spc
, flags
, false);
292 dump_generic_node (pp
, max
, spc
, flags
, false);
296 pp_string (pp
, "<unknown>");
297 pp_right_bracket (pp
);
301 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
302 dump_generic_node. */
305 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, int flags
)
309 switch (OMP_CLAUSE_CODE (clause
))
311 case OMP_CLAUSE_PRIVATE
:
314 case OMP_CLAUSE_SHARED
:
317 case OMP_CLAUSE_FIRSTPRIVATE
:
318 name
= "firstprivate";
320 case OMP_CLAUSE_LASTPRIVATE
:
321 name
= "lastprivate";
323 case OMP_CLAUSE_COPYIN
:
326 case OMP_CLAUSE_COPYPRIVATE
:
327 name
= "copyprivate";
329 case OMP_CLAUSE_UNIFORM
:
332 case OMP_CLAUSE_USE_DEVICE_PTR
:
333 name
= "use_device_ptr";
335 case OMP_CLAUSE_IS_DEVICE_PTR
:
336 name
= "is_device_ptr";
338 case OMP_CLAUSE__LOOPTEMP_
:
341 case OMP_CLAUSE_DEVICE_RESIDENT
:
342 name
= "device_resident";
344 case OMP_CLAUSE_USE_DEVICE
:
347 case OMP_CLAUSE_TO_DECLARE
:
350 case OMP_CLAUSE_LINK
:
354 pp_string (pp
, name
);
356 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
361 case OMP_CLAUSE_REDUCTION
:
362 pp_string (pp
, "reduction(");
363 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
366 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
369 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
375 pp_string (pp
, "if(");
376 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
378 case ERROR_MARK
: break;
379 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
380 case OMP_TASK
: pp_string (pp
, "task:"); break;
381 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
382 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
383 case OMP_TARGET
: pp_string (pp
, "target:"); break;
384 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
385 case OMP_TARGET_ENTER_DATA
:
386 pp_string (pp
, "target enter data:"); break;
387 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
388 default: gcc_unreachable ();
390 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
395 case OMP_CLAUSE_NUM_THREADS
:
396 pp_string (pp
, "num_threads(");
397 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
402 case OMP_CLAUSE__CILK_FOR_COUNT_
:
403 pp_string (pp
, "_Cilk_for_count_(");
404 dump_generic_node (pp
, OMP_CLAUSE_OPERAND (clause
, 0),
409 case OMP_CLAUSE_NOWAIT
:
410 pp_string (pp
, "nowait");
412 case OMP_CLAUSE_ORDERED
:
413 pp_string (pp
, "ordered");
414 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
417 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
423 case OMP_CLAUSE_DEFAULT
:
424 pp_string (pp
, "default(");
425 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
427 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
429 case OMP_CLAUSE_DEFAULT_SHARED
:
430 pp_string (pp
, "shared");
432 case OMP_CLAUSE_DEFAULT_NONE
:
433 pp_string (pp
, "none");
435 case OMP_CLAUSE_DEFAULT_PRIVATE
:
436 pp_string (pp
, "private");
438 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
439 pp_string (pp
, "firstprivate");
447 case OMP_CLAUSE_SCHEDULE
:
448 pp_string (pp
, "schedule(");
449 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
450 pp_string (pp
, "simd:");
451 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
))
453 case OMP_CLAUSE_SCHEDULE_STATIC
:
454 pp_string (pp
, "static");
456 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
457 pp_string (pp
, "dynamic");
459 case OMP_CLAUSE_SCHEDULE_GUIDED
:
460 pp_string (pp
, "guided");
462 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
463 pp_string (pp
, "runtime");
465 case OMP_CLAUSE_SCHEDULE_AUTO
:
466 pp_string (pp
, "auto");
468 case OMP_CLAUSE_SCHEDULE_CILKFOR
:
469 pp_string (pp
, "cilk-for grain");
474 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
477 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
483 case OMP_CLAUSE_UNTIED
:
484 pp_string (pp
, "untied");
487 case OMP_CLAUSE_COLLAPSE
:
488 pp_string (pp
, "collapse(");
489 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
494 case OMP_CLAUSE_FINAL
:
495 pp_string (pp
, "final(");
496 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
501 case OMP_CLAUSE_MERGEABLE
:
502 pp_string (pp
, "mergeable");
505 case OMP_CLAUSE_LINEAR
:
506 pp_string (pp
, "linear(");
507 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
509 case OMP_CLAUSE_LINEAR_DEFAULT
:
511 case OMP_CLAUSE_LINEAR_REF
:
512 pp_string (pp
, "ref(");
514 case OMP_CLAUSE_LINEAR_VAL
:
515 pp_string (pp
, "val(");
517 case OMP_CLAUSE_LINEAR_UVAL
:
518 pp_string (pp
, "uval(");
523 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
525 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
528 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
533 case OMP_CLAUSE_ALIGNED
:
534 pp_string (pp
, "aligned(");
535 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
537 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
540 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
546 case OMP_CLAUSE_DEPEND
:
547 pp_string (pp
, "depend(");
548 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
550 case OMP_CLAUSE_DEPEND_IN
:
551 pp_string (pp
, "in");
553 case OMP_CLAUSE_DEPEND_OUT
:
554 pp_string (pp
, "out");
556 case OMP_CLAUSE_DEPEND_INOUT
:
557 pp_string (pp
, "inout");
559 case OMP_CLAUSE_DEPEND_SOURCE
:
560 pp_string (pp
, "source)");
562 case OMP_CLAUSE_DEPEND_SINK
:
563 pp_string (pp
, "sink:");
564 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
565 if (TREE_CODE (t
) == TREE_LIST
)
567 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
568 if (TREE_PURPOSE (t
) != integer_zero_node
)
570 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
574 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
588 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
594 pp_string (pp
, "map(");
595 switch (OMP_CLAUSE_MAP_KIND (clause
))
598 case GOMP_MAP_POINTER
:
599 pp_string (pp
, "alloc");
602 case GOMP_MAP_TO_PSET
:
603 pp_string (pp
, "to");
606 pp_string (pp
, "from");
608 case GOMP_MAP_TOFROM
:
609 pp_string (pp
, "tofrom");
611 case GOMP_MAP_FORCE_ALLOC
:
612 pp_string (pp
, "force_alloc");
614 case GOMP_MAP_FORCE_TO
:
615 pp_string (pp
, "force_to");
617 case GOMP_MAP_FORCE_FROM
:
618 pp_string (pp
, "force_from");
620 case GOMP_MAP_FORCE_TOFROM
:
621 pp_string (pp
, "force_tofrom");
623 case GOMP_MAP_FORCE_PRESENT
:
624 pp_string (pp
, "force_present");
626 case GOMP_MAP_FORCE_DEALLOC
:
627 pp_string (pp
, "delete");
629 case GOMP_MAP_FORCE_DEVICEPTR
:
630 pp_string (pp
, "force_deviceptr");
632 case GOMP_MAP_ALWAYS_TO
:
633 pp_string (pp
, "always,to");
635 case GOMP_MAP_ALWAYS_FROM
:
636 pp_string (pp
, "always,from");
638 case GOMP_MAP_ALWAYS_TOFROM
:
639 pp_string (pp
, "always,tofrom");
641 case GOMP_MAP_RELEASE
:
642 pp_string (pp
, "release");
644 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
645 pp_string (pp
, "firstprivate");
647 case GOMP_MAP_STRUCT
:
648 pp_string (pp
, "struct");
654 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
657 if (OMP_CLAUSE_SIZE (clause
))
659 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
660 && (OMP_CLAUSE_MAP_KIND (clause
) == GOMP_MAP_POINTER
661 || OMP_CLAUSE_MAP_KIND (clause
)
662 == GOMP_MAP_FIRSTPRIVATE_POINTER
))
663 pp_string (pp
, " [pointer assign, bias: ");
664 else if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
665 && OMP_CLAUSE_MAP_KIND (clause
) == GOMP_MAP_TO_PSET
)
666 pp_string (pp
, " [pointer set, len: ");
668 pp_string (pp
, " [len: ");
669 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
671 pp_right_bracket (pp
);
676 case OMP_CLAUSE_FROM
:
677 pp_string (pp
, "from(");
678 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
680 goto print_clause_size
;
683 pp_string (pp
, "to(");
684 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
686 goto print_clause_size
;
688 case OMP_CLAUSE__CACHE_
:
690 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
692 goto print_clause_size
;
694 case OMP_CLAUSE_NUM_TEAMS
:
695 pp_string (pp
, "num_teams(");
696 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
701 case OMP_CLAUSE_THREAD_LIMIT
:
702 pp_string (pp
, "thread_limit(");
703 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
708 case OMP_CLAUSE_DEVICE
:
709 pp_string (pp
, "device(");
710 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
715 case OMP_CLAUSE_DIST_SCHEDULE
:
716 pp_string (pp
, "dist_schedule(static");
717 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
720 dump_generic_node (pp
,
721 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
727 case OMP_CLAUSE_PROC_BIND
:
728 pp_string (pp
, "proc_bind(");
729 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
731 case OMP_CLAUSE_PROC_BIND_MASTER
:
732 pp_string (pp
, "master");
734 case OMP_CLAUSE_PROC_BIND_CLOSE
:
735 pp_string (pp
, "close");
737 case OMP_CLAUSE_PROC_BIND_SPREAD
:
738 pp_string (pp
, "spread");
746 case OMP_CLAUSE_SAFELEN
:
747 pp_string (pp
, "safelen(");
748 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
753 case OMP_CLAUSE_SIMDLEN
:
754 pp_string (pp
, "simdlen(");
755 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
760 case OMP_CLAUSE_PRIORITY
:
761 pp_string (pp
, "priority(");
762 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
767 case OMP_CLAUSE_GRAINSIZE
:
768 pp_string (pp
, "grainsize(");
769 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
774 case OMP_CLAUSE_NUM_TASKS
:
775 pp_string (pp
, "num_tasks(");
776 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
781 case OMP_CLAUSE_HINT
:
782 pp_string (pp
, "hint(");
783 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
788 case OMP_CLAUSE_DEFAULTMAP
:
789 pp_string (pp
, "defaultmap(tofrom:scalar)");
792 case OMP_CLAUSE__SIMDUID_
:
793 pp_string (pp
, "_simduid_(");
794 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
799 case OMP_CLAUSE_GANG
:
800 pp_string (pp
, "gang");
801 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
803 pp_string (pp
, "(num: ");
804 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
807 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
809 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
813 pp_string (pp
, "static:");
814 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
815 == integer_minus_one_node
)
816 pp_character (pp
, '*');
818 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
821 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
822 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
826 case OMP_CLAUSE_ASYNC
:
827 pp_string (pp
, "async");
828 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
830 pp_character(pp
, '(');
831 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
833 pp_character(pp
, ')');
837 case OMP_CLAUSE_AUTO
:
839 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
842 case OMP_CLAUSE_WAIT
:
843 pp_string (pp
, "wait(");
844 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
846 pp_character(pp
, ')');
849 case OMP_CLAUSE_WORKER
:
850 pp_string (pp
, "worker");
851 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
854 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
860 case OMP_CLAUSE_VECTOR
:
861 pp_string (pp
, "vector");
862 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
865 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
871 case OMP_CLAUSE_NUM_GANGS
:
872 pp_string (pp
, "num_gangs(");
873 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
875 pp_character (pp
, ')');
878 case OMP_CLAUSE_NUM_WORKERS
:
879 pp_string (pp
, "num_workers(");
880 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
882 pp_character (pp
, ')');
885 case OMP_CLAUSE_VECTOR_LENGTH
:
886 pp_string (pp
, "vector_length(");
887 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
889 pp_character (pp
, ')');
892 case OMP_CLAUSE_INBRANCH
:
893 pp_string (pp
, "inbranch");
895 case OMP_CLAUSE_NOTINBRANCH
:
896 pp_string (pp
, "notinbranch");
899 pp_string (pp
, "for");
901 case OMP_CLAUSE_PARALLEL
:
902 pp_string (pp
, "parallel");
904 case OMP_CLAUSE_SECTIONS
:
905 pp_string (pp
, "sections");
907 case OMP_CLAUSE_TASKGROUP
:
908 pp_string (pp
, "taskgroup");
910 case OMP_CLAUSE_NOGROUP
:
911 pp_string (pp
, "nogroup");
913 case OMP_CLAUSE_THREADS
:
914 pp_string (pp
, "threads");
916 case OMP_CLAUSE_SIMD
:
917 pp_string (pp
, "simd");
919 case OMP_CLAUSE_INDEPENDENT
:
920 pp_string (pp
, "independent");
924 /* Should never happen. */
925 dump_generic_node (pp
, clause
, spc
, flags
, false);
931 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
932 dump_generic_node. */
935 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, int flags
)
943 dump_omp_clause (pp
, clause
, spc
, flags
);
944 clause
= OMP_CLAUSE_CHAIN (clause
);
952 /* Dump location LOC to PP. */
955 dump_location (pretty_printer
*pp
, location_t loc
)
957 expanded_location xloc
= expand_location (loc
);
959 pp_left_bracket (pp
);
962 pp_string (pp
, xloc
.file
);
965 pp_decimal_int (pp
, xloc
.line
);
967 pp_decimal_int (pp
, xloc
.column
);
968 pp_string (pp
, "] ");
972 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
973 dump_generic_node. */
976 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, int flags
)
980 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
982 if (flags
& TDF_ADDRESS
)
983 pp_printf (pp
, "[%p] ", (void *) block
);
985 if (BLOCK_ABSTRACT (block
))
986 pp_string (pp
, "[abstract] ");
988 if (TREE_ASM_WRITTEN (block
))
989 pp_string (pp
, "[written] ");
991 if (flags
& TDF_SLIM
)
994 if (BLOCK_SOURCE_LOCATION (block
))
995 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
997 newline_and_indent (pp
, spc
+ 2);
999 if (BLOCK_SUPERCONTEXT (block
))
1001 pp_string (pp
, "SUPERCONTEXT: ");
1002 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1003 flags
| TDF_SLIM
, false);
1004 newline_and_indent (pp
, spc
+ 2);
1007 if (BLOCK_SUBBLOCKS (block
))
1009 pp_string (pp
, "SUBBLOCKS: ");
1010 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1012 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1015 newline_and_indent (pp
, spc
+ 2);
1018 if (BLOCK_CHAIN (block
))
1020 pp_string (pp
, "SIBLINGS: ");
1021 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1023 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1026 newline_and_indent (pp
, spc
+ 2);
1029 if (BLOCK_VARS (block
))
1031 pp_string (pp
, "VARS: ");
1032 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1034 dump_generic_node (pp
, t
, 0, flags
, false);
1037 newline_and_indent (pp
, spc
+ 2);
1040 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1043 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1045 pp_string (pp
, "NONLOCALIZED_VARS: ");
1046 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1048 dump_generic_node (pp
, t
, 0, flags
, false);
1051 newline_and_indent (pp
, spc
+ 2);
1054 if (BLOCK_ABSTRACT_ORIGIN (block
))
1056 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1057 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1058 flags
| TDF_SLIM
, false);
1059 newline_and_indent (pp
, spc
+ 2);
1062 if (BLOCK_FRAGMENT_ORIGIN (block
))
1064 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1065 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1066 flags
| TDF_SLIM
, false);
1067 newline_and_indent (pp
, spc
+ 2);
1070 if (BLOCK_FRAGMENT_CHAIN (block
))
1072 pp_string (pp
, "FRAGMENT_CHAIN: ");
1073 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1075 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1078 newline_and_indent (pp
, spc
+ 2);
1083 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1084 indent. FLAGS specifies details to show in the dump (see TDF_* in
1085 dumpfile.h). If IS_STMT is true, the object printed is considered
1086 to be a statement and it is terminated by ';' if appropriate. */
1089 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, int flags
,
1096 enum tree_code code
;
1098 if (node
== NULL_TREE
)
1101 is_expr
= EXPR_P (node
);
1103 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1104 pp_printf (pp
, "<&%p> ", (void *)node
);
1106 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1107 dump_location (pp
, EXPR_LOCATION (node
));
1109 code
= TREE_CODE (node
);
1113 pp_string (pp
, "<<< error >>>");
1116 case IDENTIFIER_NODE
:
1117 pp_tree_identifier (pp
, node
);
1121 while (node
&& node
!= error_mark_node
)
1123 if (TREE_PURPOSE (node
))
1125 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1128 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1129 node
= TREE_CHAIN (node
);
1130 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1139 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1145 if (TREE_VEC_LENGTH (node
) > 0)
1147 size_t len
= TREE_VEC_LENGTH (node
);
1148 for (i
= 0; i
< len
- 1; i
++)
1150 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1155 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1162 case POINTER_BOUNDS_TYPE
:
1165 case FIXED_POINT_TYPE
:
1171 unsigned int quals
= TYPE_QUALS (node
);
1172 enum tree_code_class tclass
;
1174 if (quals
& TYPE_QUAL_ATOMIC
)
1175 pp_string (pp
, "atomic ");
1176 if (quals
& TYPE_QUAL_CONST
)
1177 pp_string (pp
, "const ");
1178 else if (quals
& TYPE_QUAL_VOLATILE
)
1179 pp_string (pp
, "volatile ");
1180 else if (quals
& TYPE_QUAL_RESTRICT
)
1181 pp_string (pp
, "restrict ");
1183 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1185 pp_string (pp
, "<address-space-");
1186 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1187 pp_string (pp
, "> ");
1190 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1192 if (tclass
== tcc_declaration
)
1194 if (DECL_NAME (node
))
1195 dump_decl_name (pp
, node
, flags
);
1197 pp_string (pp
, "<unnamed type decl>");
1199 else if (tclass
== tcc_type
)
1201 if (TYPE_NAME (node
))
1203 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1204 pp_tree_identifier (pp
, TYPE_NAME (node
));
1205 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1206 && DECL_NAME (TYPE_NAME (node
)))
1207 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1209 pp_string (pp
, "<unnamed type>");
1211 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1213 pp_string (pp
, "vector");
1215 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1216 pp_string (pp
, ") ");
1217 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1219 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1221 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1222 pp_string (pp
, (TYPE_UNSIGNED (node
)
1225 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1226 pp_string (pp
, (TYPE_UNSIGNED (node
)
1229 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1230 pp_string (pp
, (TYPE_UNSIGNED (node
)
1233 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1234 pp_string (pp
, (TYPE_UNSIGNED (node
)
1237 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1238 pp_string (pp
, (TYPE_UNSIGNED (node
)
1239 ? "unsigned long long"
1240 : "signed long long"));
1241 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1242 && exact_log2 (TYPE_PRECISION (node
)) != -1)
1244 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1245 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1246 pp_string (pp
, "_t");
1250 pp_string (pp
, (TYPE_UNSIGNED (node
)
1251 ? "<unnamed-unsigned:"
1252 : "<unnamed-signed:"));
1253 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1257 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1259 pp_string (pp
, "__complex__ ");
1260 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1262 else if (TREE_CODE (node
) == REAL_TYPE
)
1264 pp_string (pp
, "<float:");
1265 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1268 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1270 pp_string (pp
, "<fixed-point-");
1271 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1272 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1275 else if (TREE_CODE (node
) == VOID_TYPE
)
1276 pp_string (pp
, "void");
1278 pp_string (pp
, "<unnamed type>");
1284 case REFERENCE_TYPE
:
1285 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1287 if (TREE_TYPE (node
) == NULL
)
1289 pp_string (pp
, str
);
1290 pp_string (pp
, "<null type>");
1292 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1294 tree fnode
= TREE_TYPE (node
);
1296 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1299 pp_string (pp
, str
);
1300 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1301 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1302 else if (flags
& TDF_NOUID
)
1303 pp_printf (pp
, "<Txxxx>");
1305 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1307 pp_right_paren (pp
);
1308 dump_function_declaration (pp
, fnode
, spc
, flags
);
1312 unsigned int quals
= TYPE_QUALS (node
);
1314 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1316 pp_string (pp
, str
);
1318 if (quals
& TYPE_QUAL_CONST
)
1319 pp_string (pp
, " const");
1320 if (quals
& TYPE_QUAL_VOLATILE
)
1321 pp_string (pp
, " volatile");
1322 if (quals
& TYPE_QUAL_RESTRICT
)
1323 pp_string (pp
, " restrict");
1325 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1327 pp_string (pp
, " <address-space-");
1328 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1332 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1333 pp_string (pp
, " {ref-all}");
1343 if (integer_zerop (TREE_OPERAND (node
, 1))
1344 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1345 infer them and MEM_ATTR caching will share MEM_REFs
1346 with differently-typed op0s. */
1347 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1348 /* Released SSA_NAMES have no TREE_TYPE. */
1349 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1350 /* Same pointer types, but ignoring POINTER_TYPE vs.
1352 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1353 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1354 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1355 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1356 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1357 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1358 /* Same value types ignoring qualifiers. */
1359 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1360 == TYPE_MAIN_VARIANT
1361 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1362 && (!(flags
& TDF_ALIAS
)
1363 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1365 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1368 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1372 dump_generic_node (pp
,
1373 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1380 pp_string (pp
, "MEM[");
1382 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1383 dump_generic_node (pp
, ptype
,
1384 spc
, flags
| TDF_SLIM
, false);
1385 pp_right_paren (pp
);
1386 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1388 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1390 pp_string (pp
, " + ");
1391 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1394 if ((flags
& TDF_ALIAS
)
1395 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1397 pp_string (pp
, " clique ");
1398 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1399 pp_string (pp
, " base ");
1400 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1402 pp_right_bracket (pp
);
1407 case TARGET_MEM_REF
:
1409 const char *sep
= "";
1412 pp_string (pp
, "MEM[");
1414 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1416 pp_string (pp
, sep
);
1418 pp_string (pp
, "symbol: ");
1419 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1424 pp_string (pp
, sep
);
1426 pp_string (pp
, "base: ");
1427 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1429 tmp
= TMR_INDEX2 (node
);
1432 pp_string (pp
, sep
);
1434 pp_string (pp
, "base: ");
1435 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1437 tmp
= TMR_INDEX (node
);
1440 pp_string (pp
, sep
);
1442 pp_string (pp
, "index: ");
1443 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1445 tmp
= TMR_STEP (node
);
1448 pp_string (pp
, sep
);
1450 pp_string (pp
, "step: ");
1451 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1453 tmp
= TMR_OFFSET (node
);
1456 pp_string (pp
, sep
);
1458 pp_string (pp
, "offset: ");
1459 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1461 pp_right_bracket (pp
);
1469 /* Print the innermost component type. */
1470 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1471 tmp
= TREE_TYPE (tmp
))
1473 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1475 /* Print the dimensions. */
1476 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1477 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1483 case QUAL_UNION_TYPE
:
1485 unsigned int quals
= TYPE_QUALS (node
);
1487 if (quals
& TYPE_QUAL_ATOMIC
)
1488 pp_string (pp
, "atomic ");
1489 if (quals
& TYPE_QUAL_CONST
)
1490 pp_string (pp
, "const ");
1491 if (quals
& TYPE_QUAL_VOLATILE
)
1492 pp_string (pp
, "volatile ");
1494 /* Print the name of the structure. */
1495 if (TREE_CODE (node
) == RECORD_TYPE
)
1496 pp_string (pp
, "struct ");
1497 else if (TREE_CODE (node
) == UNION_TYPE
)
1498 pp_string (pp
, "union ");
1500 if (TYPE_NAME (node
))
1501 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1502 else if (!(flags
& TDF_SLIM
))
1503 /* FIXME: If we eliminate the 'else' above and attempt
1504 to show the fields for named types, we may get stuck
1505 following a cycle of pointers to structs. The alleged
1506 self-reference check in print_struct_decl will not detect
1507 cycles involving more than one pointer or struct type. */
1508 print_struct_decl (pp
, node
, spc
, flags
);
1517 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
1519 /* In the case of a pointer, one may want to divide by the
1520 size of the pointed-to type. Unfortunately, this not
1521 straightforward. The C front-end maps expressions
1526 in such a way that the two INTEGER_CST nodes for "5" have
1527 different values but identical types. In the latter
1528 case, the 5 is multiplied by sizeof (int) in c-common.c
1529 (pointer_int_sum) to convert it to a byte address, and
1530 yet the type of the node is left unchanged. Argh. What
1531 is consistent though is that the number value corresponds
1532 to bytes (UNITS) offset.
1534 NB: Neither of the following divisors can be trivially
1535 used to recover the original literal:
1537 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1538 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1539 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1540 pp_string (pp
, "B"); /* pseudo-unit */
1542 else if (tree_fits_shwi_p (node
))
1543 pp_wide_integer (pp
, tree_to_shwi (node
));
1544 else if (tree_fits_uhwi_p (node
))
1545 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1548 wide_int val
= node
;
1550 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1555 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
1556 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
1558 if (TREE_OVERFLOW (node
))
1559 pp_string (pp
, "(OVF)");
1563 /* Code copied from print_node. */
1566 if (TREE_OVERFLOW (node
))
1567 pp_string (pp
, " overflow");
1569 d
= TREE_REAL_CST (node
);
1570 if (REAL_VALUE_ISINF (d
))
1571 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1572 else if (REAL_VALUE_ISNAN (d
))
1573 pp_string (pp
, " Nan");
1577 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1578 pp_string (pp
, string
);
1586 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1587 pp_string (pp
, string
);
1592 pp_string (pp
, "__complex__ (");
1593 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
1594 pp_string (pp
, ", ");
1595 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
1596 pp_right_paren (pp
);
1600 pp_string (pp
, "\"");
1601 pretty_print_string (pp
, TREE_STRING_POINTER (node
));
1602 pp_string (pp
, "\"");
1608 pp_string (pp
, "{ ");
1609 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1612 pp_string (pp
, ", ");
1613 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
1616 pp_string (pp
, " }");
1622 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1624 if (TREE_CODE (node
) == METHOD_TYPE
)
1626 if (TYPE_METHOD_BASETYPE (node
))
1627 dump_decl_name (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1630 pp_string (pp
, "<null method basetype>");
1631 pp_colon_colon (pp
);
1633 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1634 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1635 else if (flags
& TDF_NOUID
)
1636 pp_printf (pp
, "<Txxxx>");
1638 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1639 dump_function_declaration (pp
, node
, spc
, flags
);
1644 dump_decl_name (pp
, node
, flags
);
1648 if (DECL_NAME (node
))
1649 dump_decl_name (pp
, node
, flags
);
1650 else if (LABEL_DECL_UID (node
) != -1)
1651 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
1654 if (flags
& TDF_NOUID
)
1655 pp_string (pp
, "<D.xxxx>");
1657 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
1662 if (DECL_IS_BUILTIN (node
))
1664 /* Don't print the declaration of built-in types. */
1667 if (DECL_NAME (node
))
1668 dump_decl_name (pp
, node
, flags
);
1669 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1671 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1672 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1673 && TYPE_METHODS (TREE_TYPE (node
)))
1675 /* The type is a c++ class: all structures have at least
1677 pp_string (pp
, "class ");
1678 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1683 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1684 ? "union" : "struct "));
1685 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1689 pp_string (pp
, "<anon>");
1695 case DEBUG_EXPR_DECL
:
1696 case NAMESPACE_DECL
:
1698 dump_decl_name (pp
, node
, flags
);
1702 pp_string (pp
, "<retval>");
1706 op0
= TREE_OPERAND (node
, 0);
1709 && (TREE_CODE (op0
) == INDIRECT_REF
1710 || (TREE_CODE (op0
) == MEM_REF
1711 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1712 && integer_zerop (TREE_OPERAND (op0
, 1))
1713 /* Dump the types of INTEGER_CSTs explicitly, for we
1714 can't infer them and MEM_ATTR caching will share
1715 MEM_REFs with differently-typed op0s. */
1716 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1717 /* Released SSA_NAMES have no TREE_TYPE. */
1718 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1719 /* Same pointer types, but ignoring POINTER_TYPE vs.
1721 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1722 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1723 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1724 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1725 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1726 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1727 /* Same value types ignoring qualifiers. */
1728 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1729 == TYPE_MAIN_VARIANT
1730 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
1731 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
1733 op0
= TREE_OPERAND (op0
, 0);
1736 if (op_prio (op0
) < op_prio (node
))
1738 dump_generic_node (pp
, op0
, spc
, flags
, false);
1739 if (op_prio (op0
) < op_prio (node
))
1740 pp_right_paren (pp
);
1741 pp_string (pp
, str
);
1742 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1743 op0
= component_ref_field_offset (node
);
1744 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1746 pp_string (pp
, "{off: ");
1747 dump_generic_node (pp
, op0
, spc
, flags
, false);
1748 pp_right_brace (pp
);
1753 pp_string (pp
, "BIT_FIELD_REF <");
1754 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1755 pp_string (pp
, ", ");
1756 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1757 pp_string (pp
, ", ");
1758 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1763 case ARRAY_RANGE_REF
:
1764 op0
= TREE_OPERAND (node
, 0);
1765 if (op_prio (op0
) < op_prio (node
))
1767 dump_generic_node (pp
, op0
, spc
, flags
, false);
1768 if (op_prio (op0
) < op_prio (node
))
1769 pp_right_paren (pp
);
1770 pp_left_bracket (pp
);
1771 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1772 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1773 pp_string (pp
, " ...");
1774 pp_right_bracket (pp
);
1776 op0
= array_ref_low_bound (node
);
1777 op1
= array_ref_element_size (node
);
1779 if (!integer_zerop (op0
)
1780 || TREE_OPERAND (node
, 2)
1781 || TREE_OPERAND (node
, 3))
1783 pp_string (pp
, "{lb: ");
1784 dump_generic_node (pp
, op0
, spc
, flags
, false);
1785 pp_string (pp
, " sz: ");
1786 dump_generic_node (pp
, op1
, spc
, flags
, false);
1787 pp_right_brace (pp
);
1793 unsigned HOST_WIDE_INT ix
;
1795 bool is_struct_init
= false;
1796 bool is_array_init
= false;
1799 if (TREE_CLOBBER_P (node
))
1800 pp_string (pp
, "CLOBBER");
1801 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1802 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1803 is_struct_init
= true;
1804 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
1805 && TYPE_DOMAIN (TREE_TYPE (node
))
1806 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
1807 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
1810 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
1811 is_array_init
= true;
1812 curidx
= wi::to_widest (minv
);
1814 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1821 dump_generic_node (pp
, field
, spc
, flags
, false);
1824 else if (is_array_init
1825 && (TREE_CODE (field
) != INTEGER_CST
1826 || curidx
!= wi::to_widest (field
)))
1828 pp_left_bracket (pp
);
1829 if (TREE_CODE (field
) == RANGE_EXPR
)
1831 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
1833 pp_string (pp
, " ... ");
1834 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
1836 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
1837 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
1840 dump_generic_node (pp
, field
, spc
, flags
, false);
1841 if (TREE_CODE (field
) == INTEGER_CST
)
1842 curidx
= wi::to_widest (field
);
1843 pp_string (pp
, "]=");
1848 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1849 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1850 val
= TREE_OPERAND (val
, 0);
1851 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1852 dump_decl_name (pp
, val
, flags
);
1854 dump_generic_node (pp
, val
, spc
, flags
, false);
1855 if (ix
!= vec_safe_length (CONSTRUCTOR_ELTS (node
)) - 1)
1861 pp_right_brace (pp
);
1868 if (flags
& TDF_SLIM
)
1870 pp_string (pp
, "<COMPOUND_EXPR>");
1874 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1875 spc
, flags
, !(flags
& TDF_SLIM
));
1876 if (flags
& TDF_SLIM
)
1877 newline_and_indent (pp
, spc
);
1884 for (tp
= &TREE_OPERAND (node
, 1);
1885 TREE_CODE (*tp
) == COMPOUND_EXPR
;
1886 tp
= &TREE_OPERAND (*tp
, 1))
1888 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
1889 spc
, flags
, !(flags
& TDF_SLIM
));
1890 if (flags
& TDF_SLIM
)
1891 newline_and_indent (pp
, spc
);
1899 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
1903 case STATEMENT_LIST
:
1905 tree_stmt_iterator si
;
1908 if (flags
& TDF_SLIM
)
1910 pp_string (pp
, "<STATEMENT_LIST>");
1914 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
1917 newline_and_indent (pp
, spc
);
1920 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
1927 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
1932 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
1937 pp_string (pp
, "TARGET_EXPR <");
1938 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
1941 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
1946 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
1951 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
1953 pp_string (pp
, "if (");
1954 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
1955 pp_right_paren (pp
);
1956 /* The lowered cond_exprs should always be printed in full. */
1957 if (COND_EXPR_THEN (node
)
1958 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
1959 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
1960 && COND_EXPR_ELSE (node
)
1961 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
1962 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
1965 dump_generic_node (pp
, COND_EXPR_THEN (node
),
1967 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1969 pp_string (pp
, " else ");
1970 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
1974 else if (!(flags
& TDF_SLIM
))
1976 /* Output COND_EXPR_THEN. */
1977 if (COND_EXPR_THEN (node
))
1979 newline_and_indent (pp
, spc
+2);
1981 newline_and_indent (pp
, spc
+4);
1982 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
1984 newline_and_indent (pp
, spc
+2);
1985 pp_right_brace (pp
);
1988 /* Output COND_EXPR_ELSE. */
1989 if (COND_EXPR_ELSE (node
)
1990 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1992 newline_and_indent (pp
, spc
);
1993 pp_string (pp
, "else");
1994 newline_and_indent (pp
, spc
+2);
1996 newline_and_indent (pp
, spc
+4);
1997 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
1999 newline_and_indent (pp
, spc
+2);
2000 pp_right_brace (pp
);
2007 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2011 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2015 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2021 if (!(flags
& TDF_SLIM
))
2023 if (BIND_EXPR_VARS (node
))
2027 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2029 print_declaration (pp
, op0
, spc
+2, flags
);
2034 newline_and_indent (pp
, spc
+2);
2035 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2036 newline_and_indent (pp
, spc
);
2037 pp_right_brace (pp
);
2043 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2044 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2046 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2048 /* Print parameters. */
2053 call_expr_arg_iterator iter
;
2054 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2056 dump_generic_node (pp
, arg
, spc
, flags
, false);
2057 if (more_call_expr_args_p (&iter
))
2064 if (CALL_EXPR_VA_ARG_PACK (node
))
2066 if (call_expr_nargs (node
) > 0)
2071 pp_string (pp
, "__builtin_va_arg_pack ()");
2073 pp_right_paren (pp
);
2075 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2078 pp_string (pp
, " [static-chain: ");
2079 dump_generic_node (pp
, op1
, spc
, flags
, false);
2080 pp_right_bracket (pp
);
2083 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2084 pp_string (pp
, " [return slot optimization]");
2085 if (CALL_EXPR_TAILCALL (node
))
2086 pp_string (pp
, " [tail call]");
2089 case WITH_CLEANUP_EXPR
:
2093 case CLEANUP_POINT_EXPR
:
2094 pp_string (pp
, "<<cleanup_point ");
2095 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2096 pp_string (pp
, ">>");
2099 case PLACEHOLDER_EXPR
:
2100 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2101 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2105 /* Binary arithmetic and logic expressions. */
2106 case WIDEN_SUM_EXPR
:
2107 case WIDEN_MULT_EXPR
:
2109 case MULT_HIGHPART_EXPR
:
2111 case POINTER_PLUS_EXPR
:
2113 case TRUNC_DIV_EXPR
:
2115 case FLOOR_DIV_EXPR
:
2116 case ROUND_DIV_EXPR
:
2117 case TRUNC_MOD_EXPR
:
2119 case FLOOR_MOD_EXPR
:
2120 case ROUND_MOD_EXPR
:
2122 case EXACT_DIV_EXPR
:
2127 case WIDEN_LSHIFT_EXPR
:
2131 case TRUTH_ANDIF_EXPR
:
2132 case TRUTH_ORIF_EXPR
:
2133 case TRUTH_AND_EXPR
:
2135 case TRUTH_XOR_EXPR
:
2149 case UNORDERED_EXPR
:
2151 const char *op
= op_symbol (node
);
2152 op0
= TREE_OPERAND (node
, 0);
2153 op1
= TREE_OPERAND (node
, 1);
2155 /* When the operands are expressions with less priority,
2156 keep semantics of the tree representation. */
2157 if (op_prio (op0
) <= op_prio (node
))
2160 dump_generic_node (pp
, op0
, spc
, flags
, false);
2161 pp_right_paren (pp
);
2164 dump_generic_node (pp
, op0
, spc
, flags
, false);
2170 /* When the operands are expressions with less priority,
2171 keep semantics of the tree representation. */
2172 if (op_prio (op1
) <= op_prio (node
))
2175 dump_generic_node (pp
, op1
, spc
, flags
, false);
2176 pp_right_paren (pp
);
2179 dump_generic_node (pp
, op1
, spc
, flags
, false);
2183 /* Unary arithmetic and logic expressions. */
2186 case TRUTH_NOT_EXPR
:
2188 case PREDECREMENT_EXPR
:
2189 case PREINCREMENT_EXPR
:
2191 if (TREE_CODE (node
) == ADDR_EXPR
2192 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2193 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2194 ; /* Do not output '&' for strings and function pointers. */
2196 pp_string (pp
, op_symbol (node
));
2198 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2201 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2202 pp_right_paren (pp
);
2205 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2208 case POSTDECREMENT_EXPR
:
2209 case POSTINCREMENT_EXPR
:
2210 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2213 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2214 pp_right_paren (pp
);
2217 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2218 pp_string (pp
, op_symbol (node
));
2222 pp_string (pp
, "MIN_EXPR <");
2223 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2224 pp_string (pp
, ", ");
2225 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2230 pp_string (pp
, "MAX_EXPR <");
2231 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2232 pp_string (pp
, ", ");
2233 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2238 pp_string (pp
, "ABS_EXPR <");
2239 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2247 case ADDR_SPACE_CONVERT_EXPR
:
2248 case FIXED_CONVERT_EXPR
:
2249 case FIX_TRUNC_EXPR
:
2252 type
= TREE_TYPE (node
);
2253 op0
= TREE_OPERAND (node
, 0);
2254 if (type
!= TREE_TYPE (op0
))
2257 dump_generic_node (pp
, type
, spc
, flags
, false);
2258 pp_string (pp
, ") ");
2260 if (op_prio (op0
) < op_prio (node
))
2262 dump_generic_node (pp
, op0
, spc
, flags
, false);
2263 if (op_prio (op0
) < op_prio (node
))
2264 pp_right_paren (pp
);
2267 case VIEW_CONVERT_EXPR
:
2268 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2269 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2270 pp_string (pp
, ">(");
2271 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2272 pp_right_paren (pp
);
2276 pp_string (pp
, "((");
2277 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2278 pp_string (pp
, "))");
2281 case NON_LVALUE_EXPR
:
2282 pp_string (pp
, "NON_LVALUE_EXPR <");
2283 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2288 pp_string (pp
, "SAVE_EXPR <");
2289 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2294 pp_string (pp
, "COMPLEX_EXPR <");
2295 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2296 pp_string (pp
, ", ");
2297 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2302 pp_string (pp
, "CONJ_EXPR <");
2303 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2308 pp_string (pp
, "REALPART_EXPR <");
2309 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2314 pp_string (pp
, "IMAGPART_EXPR <");
2315 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2320 pp_string (pp
, "VA_ARG_EXPR <");
2321 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2325 case TRY_FINALLY_EXPR
:
2326 case TRY_CATCH_EXPR
:
2327 pp_string (pp
, "try");
2328 newline_and_indent (pp
, spc
+2);
2330 newline_and_indent (pp
, spc
+4);
2331 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2332 newline_and_indent (pp
, spc
+2);
2333 pp_right_brace (pp
);
2334 newline_and_indent (pp
, spc
);
2336 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2337 newline_and_indent (pp
, spc
+2);
2339 newline_and_indent (pp
, spc
+4);
2340 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2341 newline_and_indent (pp
, spc
+2);
2342 pp_right_brace (pp
);
2347 pp_string (pp
, "catch (");
2348 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2349 pp_right_paren (pp
);
2350 newline_and_indent (pp
, spc
+2);
2352 newline_and_indent (pp
, spc
+4);
2353 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2354 newline_and_indent (pp
, spc
+2);
2355 pp_right_brace (pp
);
2359 case EH_FILTER_EXPR
:
2360 pp_string (pp
, "<<<eh_filter (");
2361 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2362 pp_string (pp
, ")>>>");
2363 newline_and_indent (pp
, spc
+2);
2365 newline_and_indent (pp
, spc
+4);
2366 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2367 newline_and_indent (pp
, spc
+2);
2368 pp_right_brace (pp
);
2373 op0
= TREE_OPERAND (node
, 0);
2374 /* If this is for break or continue, don't bother printing it. */
2375 if (DECL_NAME (op0
))
2377 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2378 if (strcmp (name
, "break") == 0
2379 || strcmp (name
, "continue") == 0)
2382 dump_generic_node (pp
, op0
, spc
, flags
, false);
2384 if (DECL_NONLOCAL (op0
))
2385 pp_string (pp
, " [non-local]");
2389 pp_string (pp
, "while (1)");
2390 if (!(flags
& TDF_SLIM
))
2392 newline_and_indent (pp
, spc
+2);
2394 newline_and_indent (pp
, spc
+4);
2395 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2396 newline_and_indent (pp
, spc
+2);
2397 pp_right_brace (pp
);
2403 pp_string (pp
, "// predicted ");
2404 if (PREDICT_EXPR_OUTCOME (node
))
2405 pp_string (pp
, "likely by ");
2407 pp_string (pp
, "unlikely by ");
2408 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2409 pp_string (pp
, " predictor.");
2413 pp_string (pp
, "ANNOTATE_EXPR <");
2414 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2415 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2417 case annot_expr_ivdep_kind
:
2418 pp_string (pp
, ", ivdep");
2420 case annot_expr_no_vector_kind
:
2421 pp_string (pp
, ", no-vector");
2423 case annot_expr_vector_kind
:
2424 pp_string (pp
, ", vector");
2433 pp_string (pp
, "return");
2434 op0
= TREE_OPERAND (node
, 0);
2438 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2439 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2442 dump_generic_node (pp
, op0
, spc
, flags
, false);
2447 pp_string (pp
, "if (");
2448 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2449 pp_string (pp
, ") break");
2453 pp_string (pp
, "switch (");
2454 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2455 pp_right_paren (pp
);
2456 if (!(flags
& TDF_SLIM
))
2458 newline_and_indent (pp
, spc
+2);
2460 if (SWITCH_BODY (node
))
2462 newline_and_indent (pp
, spc
+4);
2463 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2468 tree vec
= SWITCH_LABELS (node
);
2469 size_t i
, n
= TREE_VEC_LENGTH (vec
);
2470 for (i
= 0; i
< n
; ++i
)
2472 tree elt
= TREE_VEC_ELT (vec
, i
);
2473 newline_and_indent (pp
, spc
+4);
2476 dump_generic_node (pp
, elt
, spc
+4, flags
, false);
2477 pp_string (pp
, " goto ");
2478 dump_generic_node (pp
, CASE_LABEL (elt
), spc
+4,
2483 pp_string (pp
, "case ???: goto ???;");
2486 newline_and_indent (pp
, spc
+2);
2487 pp_right_brace (pp
);
2493 op0
= GOTO_DESTINATION (node
);
2494 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2496 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2497 if (strcmp (name
, "break") == 0
2498 || strcmp (name
, "continue") == 0)
2500 pp_string (pp
, name
);
2504 pp_string (pp
, "goto ");
2505 dump_generic_node (pp
, op0
, spc
, flags
, false);
2509 pp_string (pp
, "__asm__");
2510 if (ASM_VOLATILE_P (node
))
2511 pp_string (pp
, " __volatile__");
2513 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2515 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2517 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2518 if (ASM_CLOBBERS (node
))
2521 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2523 pp_right_paren (pp
);
2526 case CASE_LABEL_EXPR
:
2527 if (CASE_LOW (node
) && CASE_HIGH (node
))
2529 pp_string (pp
, "case ");
2530 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2531 pp_string (pp
, " ... ");
2532 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2534 else if (CASE_LOW (node
))
2536 pp_string (pp
, "case ");
2537 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2540 pp_string (pp
, "default");
2545 pp_string (pp
, "OBJ_TYPE_REF(");
2546 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2548 if (!(flags
& TDF_SLIM
) && virtual_method_call_p (node
))
2550 pp_string (pp
, "(");
2551 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2552 pp_string (pp
, ")");
2554 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2556 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2557 pp_right_paren (pp
);
2561 if (SSA_NAME_IDENTIFIER (node
))
2562 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2565 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2566 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2567 pp_string (pp
, "(D)");
2568 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2569 pp_string (pp
, "(ab)");
2572 case WITH_SIZE_EXPR
:
2573 pp_string (pp
, "WITH_SIZE_EXPR <");
2574 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2575 pp_string (pp
, ", ");
2576 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2581 pp_string (pp
, "ASSERT_EXPR <");
2582 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2583 pp_string (pp
, ", ");
2584 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2589 pp_string (pp
, "scev_known");
2592 case SCEV_NOT_KNOWN
:
2593 pp_string (pp
, "scev_not_known");
2596 case POLYNOMIAL_CHREC
:
2598 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2599 pp_string (pp
, ", +, ");
2600 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2601 pp_string (pp
, "}_");
2602 dump_generic_node (pp
, CHREC_VAR (node
), spc
, flags
, false);
2606 case REALIGN_LOAD_EXPR
:
2607 pp_string (pp
, "REALIGN_LOAD <");
2608 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2609 pp_string (pp
, ", ");
2610 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2611 pp_string (pp
, ", ");
2612 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2617 pp_string (pp
, " VEC_COND_EXPR < ");
2618 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2619 pp_string (pp
, " , ");
2620 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2621 pp_string (pp
, " , ");
2622 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2623 pp_string (pp
, " > ");
2627 pp_string (pp
, " VEC_PERM_EXPR < ");
2628 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2629 pp_string (pp
, " , ");
2630 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2631 pp_string (pp
, " , ");
2632 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2633 pp_string (pp
, " > ");
2637 pp_string (pp
, " DOT_PROD_EXPR < ");
2638 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2639 pp_string (pp
, ", ");
2640 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2641 pp_string (pp
, ", ");
2642 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2643 pp_string (pp
, " > ");
2646 case WIDEN_MULT_PLUS_EXPR
:
2647 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
2648 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2649 pp_string (pp
, ", ");
2650 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2651 pp_string (pp
, ", ");
2652 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2653 pp_string (pp
, " > ");
2656 case WIDEN_MULT_MINUS_EXPR
:
2657 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
2658 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2659 pp_string (pp
, ", ");
2660 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2661 pp_string (pp
, ", ");
2662 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2663 pp_string (pp
, " > ");
2667 pp_string (pp
, " FMA_EXPR < ");
2668 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2669 pp_string (pp
, ", ");
2670 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2671 pp_string (pp
, ", ");
2672 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2673 pp_string (pp
, " > ");
2677 pp_string (pp
, "#pragma acc parallel");
2678 goto dump_omp_clauses_body
;
2681 pp_string (pp
, "#pragma acc kernels");
2682 goto dump_omp_clauses_body
;
2685 pp_string (pp
, "#pragma acc data");
2686 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2689 case OACC_HOST_DATA
:
2690 pp_string (pp
, "#pragma acc host_data");
2691 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2695 pp_string (pp
, "#pragma acc declare");
2696 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2700 pp_string (pp
, "#pragma acc update");
2701 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2704 case OACC_ENTER_DATA
:
2705 pp_string (pp
, "#pragma acc enter data");
2706 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2709 case OACC_EXIT_DATA
:
2710 pp_string (pp
, "#pragma acc exit data");
2711 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2715 pp_string (pp
, "#pragma acc cache");
2716 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2720 pp_string (pp
, "#pragma omp parallel");
2721 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2724 dump_omp_clauses_body
:
2725 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2729 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2731 newline_and_indent (pp
, spc
+ 2);
2733 newline_and_indent (pp
, spc
+ 4);
2734 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2735 newline_and_indent (pp
, spc
+ 2);
2736 pp_right_brace (pp
);
2742 pp_string (pp
, "#pragma omp task");
2743 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2747 pp_string (pp
, "#pragma omp for");
2751 pp_string (pp
, "#pragma omp simd");
2755 pp_string (pp
, "#pragma simd");
2759 /* This label points one line after dumping the clauses.
2760 For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2761 parameters are printed out. */
2762 goto dump_omp_loop_cilk_for
;
2764 case OMP_DISTRIBUTE
:
2765 pp_string (pp
, "#pragma omp distribute");
2769 pp_string (pp
, "#pragma omp taskloop");
2773 pp_string (pp
, "#pragma acc loop");
2777 pp_string (pp
, "#pragma omp teams");
2778 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
2781 case OMP_TARGET_DATA
:
2782 pp_string (pp
, "#pragma omp target data");
2783 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
2786 case OMP_TARGET_ENTER_DATA
:
2787 pp_string (pp
, "#pragma omp target enter data");
2788 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2792 case OMP_TARGET_EXIT_DATA
:
2793 pp_string (pp
, "#pragma omp target exit data");
2794 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2799 pp_string (pp
, "#pragma omp target");
2800 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
2803 case OMP_TARGET_UPDATE
:
2804 pp_string (pp
, "#pragma omp target update");
2805 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
2810 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2812 dump_omp_loop_cilk_for
:
2813 if (!(flags
& TDF_SLIM
))
2817 if (OMP_FOR_PRE_BODY (node
))
2819 if (TREE_CODE (node
) == CILK_FOR
)
2820 pp_string (pp
, " ");
2822 newline_and_indent (pp
, spc
+ 2);
2825 newline_and_indent (pp
, spc
);
2826 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
2829 if (OMP_FOR_INIT (node
))
2832 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
2835 if (TREE_CODE (node
) != CILK_FOR
|| OMP_FOR_PRE_BODY (node
))
2836 newline_and_indent (pp
, spc
);
2837 if (TREE_CODE (node
) == CILK_FOR
)
2838 pp_string (pp
, "_Cilk_for (");
2840 pp_string (pp
, "for (");
2841 dump_generic_node (pp
,
2842 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
2844 pp_string (pp
, "; ");
2845 dump_generic_node (pp
,
2846 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
2848 pp_string (pp
, "; ");
2849 dump_generic_node (pp
,
2850 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
2852 pp_right_paren (pp
);
2854 if (TREE_CODE (node
) == CILK_FOR
)
2855 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2857 if (OMP_FOR_BODY (node
))
2859 newline_and_indent (pp
, spc
+ 2);
2861 newline_and_indent (pp
, spc
+ 4);
2862 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
2864 newline_and_indent (pp
, spc
+ 2);
2865 pp_right_brace (pp
);
2867 if (OMP_FOR_INIT (node
))
2868 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
2869 if (OMP_FOR_PRE_BODY (node
))
2872 newline_and_indent (pp
, spc
+ 2);
2873 pp_right_brace (pp
);
2880 pp_string (pp
, "#pragma omp sections");
2881 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
2885 pp_string (pp
, "#pragma omp section");
2889 pp_string (pp
, "#pragma omp master");
2893 pp_string (pp
, "#pragma omp taskgroup");
2897 pp_string (pp
, "#pragma omp ordered");
2898 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
2902 pp_string (pp
, "#pragma omp critical");
2903 if (OMP_CRITICAL_NAME (node
))
2907 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
2909 pp_right_paren (pp
);
2911 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
2915 pp_string (pp
, "#pragma omp atomic");
2916 if (OMP_ATOMIC_SEQ_CST (node
))
2917 pp_string (pp
, " seq_cst");
2918 newline_and_indent (pp
, spc
+ 2);
2919 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2923 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2926 case OMP_ATOMIC_READ
:
2927 pp_string (pp
, "#pragma omp atomic read");
2928 if (OMP_ATOMIC_SEQ_CST (node
))
2929 pp_string (pp
, " seq_cst");
2930 newline_and_indent (pp
, spc
+ 2);
2931 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2935 case OMP_ATOMIC_CAPTURE_OLD
:
2936 case OMP_ATOMIC_CAPTURE_NEW
:
2937 pp_string (pp
, "#pragma omp atomic capture");
2938 if (OMP_ATOMIC_SEQ_CST (node
))
2939 pp_string (pp
, " seq_cst");
2940 newline_and_indent (pp
, spc
+ 2);
2941 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2945 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2949 pp_string (pp
, "#pragma omp single");
2950 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
2954 dump_omp_clause (pp
, node
, spc
, flags
);
2958 case TRANSACTION_EXPR
:
2959 if (TRANSACTION_EXPR_OUTER (node
))
2960 pp_string (pp
, "__transaction_atomic [[outer]]");
2961 else if (TRANSACTION_EXPR_RELAXED (node
))
2962 pp_string (pp
, "__transaction_relaxed");
2964 pp_string (pp
, "__transaction_atomic");
2965 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
2967 newline_and_indent (pp
, spc
);
2969 newline_and_indent (pp
, spc
+ 2);
2970 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
2971 spc
+ 2, flags
, false);
2972 newline_and_indent (pp
, spc
);
2973 pp_right_brace (pp
);
2978 case REDUC_MAX_EXPR
:
2979 pp_string (pp
, " REDUC_MAX_EXPR < ");
2980 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2981 pp_string (pp
, " > ");
2984 case REDUC_MIN_EXPR
:
2985 pp_string (pp
, " REDUC_MIN_EXPR < ");
2986 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2987 pp_string (pp
, " > ");
2990 case REDUC_PLUS_EXPR
:
2991 pp_string (pp
, " REDUC_PLUS_EXPR < ");
2992 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2993 pp_string (pp
, " > ");
2996 case VEC_WIDEN_MULT_HI_EXPR
:
2997 case VEC_WIDEN_MULT_LO_EXPR
:
2998 case VEC_WIDEN_MULT_EVEN_EXPR
:
2999 case VEC_WIDEN_MULT_ODD_EXPR
:
3000 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3001 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3003 for (str
= get_tree_code_name (code
); *str
; str
++)
3004 pp_character (pp
, TOUPPER (*str
));
3005 pp_string (pp
, " < ");
3006 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3007 pp_string (pp
, ", ");
3008 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3009 pp_string (pp
, " > ");
3012 case VEC_UNPACK_HI_EXPR
:
3013 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3014 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3015 pp_string (pp
, " > ");
3018 case VEC_UNPACK_LO_EXPR
:
3019 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3020 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3021 pp_string (pp
, " > ");
3024 case VEC_UNPACK_FLOAT_HI_EXPR
:
3025 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3026 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3027 pp_string (pp
, " > ");
3030 case VEC_UNPACK_FLOAT_LO_EXPR
:
3031 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3032 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3033 pp_string (pp
, " > ");
3036 case VEC_PACK_TRUNC_EXPR
:
3037 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3038 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3039 pp_string (pp
, ", ");
3040 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3041 pp_string (pp
, " > ");
3044 case VEC_PACK_SAT_EXPR
:
3045 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3046 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3047 pp_string (pp
, ", ");
3048 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3049 pp_string (pp
, " > ");
3052 case VEC_PACK_FIX_TRUNC_EXPR
:
3053 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3054 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3055 pp_string (pp
, ", ");
3056 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3057 pp_string (pp
, " > ");
3061 dump_block_node (pp
, node
, spc
, flags
);
3064 case CILK_SPAWN_STMT
:
3065 pp_string (pp
, "_Cilk_spawn ");
3066 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3069 case CILK_SYNC_STMT
:
3070 pp_string (pp
, "_Cilk_sync");
3077 if (is_stmt
&& is_expr
)
3083 /* Print the declaration of a variable. */
3086 print_declaration (pretty_printer
*pp
, tree t
, int spc
, int flags
)
3090 if (TREE_CODE(t
) == NAMELIST_DECL
)
3092 pp_string(pp
, "namelist ");
3093 dump_decl_name (pp
, t
, flags
);
3098 if (TREE_CODE (t
) == TYPE_DECL
)
3099 pp_string (pp
, "typedef ");
3101 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3102 pp_string (pp
, "register ");
3104 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3105 pp_string (pp
, "extern ");
3106 else if (TREE_STATIC (t
))
3107 pp_string (pp
, "static ");
3109 /* Print the type and name. */
3110 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3114 /* Print array's type. */
3115 tmp
= TREE_TYPE (t
);
3116 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3117 tmp
= TREE_TYPE (tmp
);
3118 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3120 /* Print variable's name. */
3122 dump_generic_node (pp
, t
, spc
, flags
, false);
3124 /* Print the dimensions. */
3125 tmp
= TREE_TYPE (t
);
3126 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3128 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3129 tmp
= TREE_TYPE (tmp
);
3132 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3134 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3136 dump_decl_name (pp
, t
, flags
);
3137 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3141 /* Print type declaration. */
3142 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3144 /* Print variable's name. */
3146 dump_generic_node (pp
, t
, spc
, flags
, false);
3149 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
3151 pp_string (pp
, " __asm__ ");
3153 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3154 pp_right_paren (pp
);
3157 /* The initial value of a function serves to determine whether the function
3158 is declared or defined. So the following does not apply to function
3160 if (TREE_CODE (t
) != FUNCTION_DECL
)
3162 /* Print the initial value. */
3163 if (DECL_INITIAL (t
))
3168 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3172 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
3174 pp_string (pp
, " [value-expr: ");
3175 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3176 pp_right_bracket (pp
);
3183 /* Prints a structure: name, fields, and methods.
3184 FIXME: Still incomplete. */
3187 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
, int flags
)
3189 /* Print the name of the structure. */
3190 if (TYPE_NAME (node
))
3193 if (TREE_CODE (node
) == RECORD_TYPE
)
3194 pp_string (pp
, "struct ");
3195 else if ((TREE_CODE (node
) == UNION_TYPE
3196 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3197 pp_string (pp
, "union ");
3199 dump_generic_node (pp
, TYPE_NAME (node
), spc
, 0, false);
3202 /* Print the contents of the structure. */
3208 /* Print the fields of the structure. */
3211 tmp
= TYPE_FIELDS (node
);
3214 /* Avoid to print recursively the structure. */
3215 /* FIXME : Not implemented correctly...,
3216 what about the case when we have a cycle in the contain graph? ...
3217 Maybe this could be solved by looking at the scope in which the
3218 structure was declared. */
3219 if (TREE_TYPE (tmp
) != node
3220 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3221 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3223 print_declaration (pp
, tmp
, spc
+2, flags
);
3226 tmp
= DECL_CHAIN (tmp
);
3230 pp_right_brace (pp
);
3233 /* Return the priority of the operator CODE.
3235 From lowest to highest precedence with either left-to-right (L-R)
3236 or right-to-left (R-L) associativity]:
3239 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3251 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3252 15 [L-R] fn() [] -> .
3254 unary +, - and * have higher precedence than the corresponding binary
3258 op_code_prio (enum tree_code code
)
3275 case TRUTH_ORIF_EXPR
:
3278 case TRUTH_AND_EXPR
:
3279 case TRUTH_ANDIF_EXPR
:
3286 case TRUTH_XOR_EXPR
:
3303 case UNORDERED_EXPR
:
3314 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3315 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3316 case WIDEN_LSHIFT_EXPR
:
3319 case WIDEN_SUM_EXPR
:
3321 case POINTER_PLUS_EXPR
:
3325 case VEC_WIDEN_MULT_HI_EXPR
:
3326 case VEC_WIDEN_MULT_LO_EXPR
:
3327 case WIDEN_MULT_EXPR
:
3329 case WIDEN_MULT_PLUS_EXPR
:
3330 case WIDEN_MULT_MINUS_EXPR
:
3332 case MULT_HIGHPART_EXPR
:
3333 case TRUNC_DIV_EXPR
:
3335 case FLOOR_DIV_EXPR
:
3336 case ROUND_DIV_EXPR
:
3338 case EXACT_DIV_EXPR
:
3339 case TRUNC_MOD_EXPR
:
3341 case FLOOR_MOD_EXPR
:
3342 case ROUND_MOD_EXPR
:
3346 case TRUTH_NOT_EXPR
:
3348 case POSTINCREMENT_EXPR
:
3349 case POSTDECREMENT_EXPR
:
3350 case PREINCREMENT_EXPR
:
3351 case PREDECREMENT_EXPR
:
3357 case FIX_TRUNC_EXPR
:
3363 case ARRAY_RANGE_REF
:
3367 /* Special expressions. */
3373 case REDUC_MAX_EXPR
:
3374 case REDUC_MIN_EXPR
:
3375 case REDUC_PLUS_EXPR
:
3376 case VEC_UNPACK_HI_EXPR
:
3377 case VEC_UNPACK_LO_EXPR
:
3378 case VEC_UNPACK_FLOAT_HI_EXPR
:
3379 case VEC_UNPACK_FLOAT_LO_EXPR
:
3380 case VEC_PACK_TRUNC_EXPR
:
3381 case VEC_PACK_SAT_EXPR
:
3385 /* Return an arbitrarily high precedence to avoid surrounding single
3386 VAR_DECLs in ()s. */
3391 /* Return the priority of the operator OP. */
3394 op_prio (const_tree op
)
3396 enum tree_code code
;
3401 code
= TREE_CODE (op
);
3402 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3403 return op_prio (TREE_OPERAND (op
, 0));
3405 return op_code_prio (code
);
3408 /* Return the symbol associated with operator CODE. */
3411 op_symbol_code (enum tree_code code
)
3419 case TRUTH_ORIF_EXPR
:
3422 case TRUTH_AND_EXPR
:
3423 case TRUTH_ANDIF_EXPR
:
3429 case TRUTH_XOR_EXPR
:
3439 case UNORDERED_EXPR
:
3485 case WIDEN_LSHIFT_EXPR
:
3488 case POINTER_PLUS_EXPR
:
3494 case REDUC_PLUS_EXPR
:
3497 case WIDEN_SUM_EXPR
:
3500 case WIDEN_MULT_EXPR
:
3503 case MULT_HIGHPART_EXPR
:
3513 case TRUTH_NOT_EXPR
:
3520 case TRUNC_DIV_EXPR
:
3527 case FLOOR_DIV_EXPR
:
3530 case ROUND_DIV_EXPR
:
3533 case EXACT_DIV_EXPR
:
3536 case TRUNC_MOD_EXPR
:
3542 case FLOOR_MOD_EXPR
:
3545 case ROUND_MOD_EXPR
:
3548 case PREDECREMENT_EXPR
:
3551 case PREINCREMENT_EXPR
:
3554 case POSTDECREMENT_EXPR
:
3557 case POSTINCREMENT_EXPR
:
3567 return "<<< ??? >>>";
3571 /* Return the symbol associated with operator OP. */
3574 op_symbol (const_tree op
)
3576 return op_symbol_code (TREE_CODE (op
));
3579 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3580 the gimple_call_fn of a GIMPLE_CALL. */
3583 print_call_name (pretty_printer
*pp
, tree node
, int flags
)
3587 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3588 op0
= TREE_OPERAND (op0
, 0);
3591 switch (TREE_CODE (op0
))
3596 dump_function_name (pp
, op0
, flags
);
3602 op0
= TREE_OPERAND (op0
, 0);
3607 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3608 pp_string (pp
, ") ? ");
3609 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3610 pp_string (pp
, " : ");
3611 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3615 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3616 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
3618 dump_generic_node (pp
, op0
, 0, flags
, false);
3622 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3624 op0
= TREE_OPERAND (op0
, 0);
3631 dump_generic_node (pp
, op0
, 0, flags
, false);
3639 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3642 pretty_print_string (pretty_printer
*pp
, const char *str
)
3652 pp_string (pp
, "\\b");
3656 pp_string (pp
, "\\f");
3660 pp_string (pp
, "\\n");
3664 pp_string (pp
, "\\r");
3668 pp_string (pp
, "\\t");
3672 pp_string (pp
, "\\v");
3676 pp_string (pp
, "\\\\");
3680 pp_string (pp
, "\\\"");
3684 pp_string (pp
, "\\'");
3687 /* No need to handle \0; the loop terminates on \0. */
3690 pp_string (pp
, "\\1");
3694 pp_string (pp
, "\\2");
3698 pp_string (pp
, "\\3");
3702 pp_string (pp
, "\\4");
3706 pp_string (pp
, "\\5");
3710 pp_string (pp
, "\\6");
3714 pp_string (pp
, "\\7");
3718 pp_character (pp
, str
[0]);
3726 maybe_init_pretty_print (FILE *file
)
3730 tree_pp
= new pretty_printer ();
3731 pp_needs_newline (tree_pp
) = true;
3732 pp_translate_identifiers (tree_pp
) = false;
3735 tree_pp
->buffer
->stream
= file
;
3739 newline_and_indent (pretty_printer
*pp
, int spc
)
3745 /* Handle a %K format for TEXT. Separate from default_tree_printer so
3746 it can also be used in front ends.
3747 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3751 percent_K_format (text_info
*text
)
3753 tree t
= va_arg (*text
->args_ptr
, tree
), block
;
3754 text
->set_location (0, EXPR_LOCATION (t
));
3755 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3756 block
= TREE_BLOCK (t
);
3757 *pp_ti_abstract_origin (text
) = NULL
;
3761 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3762 representing the outermost block of an inlined function.
3763 So walk the BLOCK tree until we hit such a scope. */
3765 && TREE_CODE (block
) == BLOCK
)
3767 if (inlined_function_outer_scope_p (block
))
3769 *pp_ti_abstract_origin (text
) = block
;
3772 block
= BLOCK_SUPERCONTEXT (block
);
3778 && TREE_CODE (block
) == BLOCK
3779 && BLOCK_ABSTRACT_ORIGIN (block
))
3781 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3783 while (TREE_CODE (ao
) == BLOCK
3784 && BLOCK_ABSTRACT_ORIGIN (ao
)
3785 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3786 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3788 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3790 *pp_ti_abstract_origin (text
) = block
;
3793 block
= BLOCK_SUPERCONTEXT (block
);
3797 /* Print the identifier ID to PRETTY-PRINTER. */
3800 pp_tree_identifier (pretty_printer
*pp
, tree id
)
3802 if (pp_translate_identifiers (pp
))
3804 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
3805 pp_append_text (pp
, text
, text
+ strlen (text
));
3808 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
3809 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
3812 /* A helper function that is used to dump function information before the
3816 dump_function_header (FILE *dump_file
, tree fdecl
, int flags
)
3818 const char *dname
, *aname
;
3819 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
3820 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
3822 dname
= lang_hooks
.decl_printable_name (fdecl
, 2);
3824 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
3825 aname
= (IDENTIFIER_POINTER
3826 (DECL_ASSEMBLER_NAME (fdecl
)));
3828 aname
= "<unset-asm-name>";
3830 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
3831 dname
, aname
, fun
->funcdef_no
);
3832 if (!(flags
& TDF_NOUID
))
3833 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
3836 fprintf (dump_file
, ", cgraph_uid=%d", node
->uid
);
3837 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
3838 node
->frequency
== NODE_FREQUENCY_HOT
3840 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
3841 ? " (unlikely executed)"
3842 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
3843 ? " (executed once)"
3847 fprintf (dump_file
, ")\n\n");
3850 /* Dump double_int D to pretty_printer PP. UNS is true
3851 if D is unsigned and false otherwise. */
3853 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
3856 pp_wide_integer (pp
, d
.low
);
3857 else if (d
.fits_uhwi ())
3858 pp_unsigned_wide_integer (pp
, d
.low
);
3861 unsigned HOST_WIDE_INT low
= d
.low
;
3862 HOST_WIDE_INT high
= d
.high
;
3863 if (!uns
&& d
.is_negative ())
3866 high
= ~high
+ !low
;
3869 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
3871 sprintf (pp_buffer (pp
)->digit_buffer
,
3872 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
3873 (unsigned HOST_WIDE_INT
) high
, low
);
3874 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);