1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2016 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"
29 #include "tree-pretty-print.h"
30 #include "stor-layout.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
34 #include "internal-fn.h"
35 #include "gomp-constants.h"
37 /* Local functions, macros and variables. */
38 static const char *op_symbol (const_tree
);
39 static void pretty_print_string (pretty_printer
*, const char*);
40 static void newline_and_indent (pretty_printer
*, int);
41 static void maybe_init_pretty_print (FILE *);
42 static void print_struct_decl (pretty_printer
*, const_tree
, int, int);
43 static void do_niy (pretty_printer
*, const_tree
, int);
45 #define INDENT(SPACE) do { \
46 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
48 #define NIY do_niy (pp, node, flags)
50 static pretty_printer
*tree_pp
;
52 /* Try to print something for an unknown tree code. */
55 do_niy (pretty_printer
*pp
, const_tree node
, int flags
)
59 pp_string (pp
, "<<< Unknown tree: ");
60 pp_string (pp
, get_tree_code_name (TREE_CODE (node
)));
64 len
= TREE_OPERAND_LENGTH (node
);
65 for (i
= 0; i
< len
; ++i
)
67 newline_and_indent (pp
, 2);
68 dump_generic_node (pp
, TREE_OPERAND (node
, i
), 2, flags
, false);
72 pp_string (pp
, " >>>");
75 /* Debugging function to print out a generic expression. */
78 debug_generic_expr (tree t
)
80 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
81 fprintf (stderr
, "\n");
84 /* Debugging function to print out a generic statement. */
87 debug_generic_stmt (tree t
)
89 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
90 fprintf (stderr
, "\n");
93 /* Debugging function to print out a chain of trees . */
96 debug_tree_chain (tree t
)
102 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
103 fprintf (stderr
, " ");
107 fprintf (stderr
, "... [cycled back to ");
108 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
109 fprintf (stderr
, "]");
113 fprintf (stderr
, "\n");
116 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
118 print_generic_decl (FILE *file
, tree decl
, int flags
)
120 maybe_init_pretty_print (file
);
121 print_declaration (tree_pp
, decl
, 2, flags
);
122 pp_write_text_to_stream (tree_pp
);
125 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
126 to show in the dump. See TDF_* in dumpfile.h. */
129 print_generic_stmt (FILE *file
, tree t
, int flags
)
131 maybe_init_pretty_print (file
);
132 dump_generic_node (tree_pp
, t
, 0, flags
, true);
133 pp_newline_and_flush (tree_pp
);
136 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
137 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
141 print_generic_stmt_indented (FILE *file
, tree t
, int flags
, int indent
)
145 maybe_init_pretty_print (file
);
147 for (i
= 0; i
< indent
; i
++)
149 dump_generic_node (tree_pp
, t
, indent
, flags
, true);
150 pp_newline_and_flush (tree_pp
);
153 /* Print a single expression T on file FILE. FLAGS specifies details to show
154 in the dump. See TDF_* in dumpfile.h. */
157 print_generic_expr (FILE *file
, tree t
, int flags
)
159 maybe_init_pretty_print (file
);
160 dump_generic_node (tree_pp
, t
, 0, flags
, false);
164 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
165 in it are replaced with Dxxxx, as long as they are at the start or
166 preceded by $ and at the end or followed by $. See make_fancy_name
170 dump_fancy_name (pretty_printer
*pp
, tree name
)
173 int length
= IDENTIFIER_LENGTH (name
);
174 const char *n
= IDENTIFIER_POINTER (name
);
181 && (n
== IDENTIFIER_POINTER (name
) || n
[-1] == '$'))
184 while (ISDIGIT (n
[l
]))
186 if (n
[l
] == '\0' || n
[l
] == '$')
199 pp_tree_identifier (pp
, name
);
203 char *str
= XNEWVEC (char, length
+ 1);
206 q
= n
= IDENTIFIER_POINTER (name
);
213 && (q
== IDENTIFIER_POINTER (name
) || q
[-1] == '$'))
216 while (ISDIGIT (q
[l
]))
218 if (q
[l
] == '\0' || q
[l
] == '$')
220 memcpy (p
, n
, q
- n
);
221 memcpy (p
+ (q
- n
), "Dxxxx", 5);
231 memcpy (p
, n
, IDENTIFIER_LENGTH (name
) - (n
- IDENTIFIER_POINTER (name
)));
233 if (pp_translate_identifiers (pp
))
235 const char *text
= identifier_to_locale (str
);
236 pp_append_text (pp
, text
, text
+ strlen (text
));
239 pp_append_text (pp
, str
, str
+ length
);
243 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
247 dump_decl_name (pretty_printer
*pp
, tree node
, int flags
)
249 if (DECL_NAME (node
))
251 if ((flags
& TDF_ASMNAME
) && DECL_ASSEMBLER_NAME_SET_P (node
))
252 pp_tree_identifier (pp
, DECL_ASSEMBLER_NAME (node
));
253 /* For DECL_NAMELESS names look for embedded uids in the
254 names and sanitize them for TDF_NOUID. */
255 else if ((flags
& TDF_NOUID
) && DECL_NAMELESS (node
))
256 dump_fancy_name (pp
, DECL_NAME (node
));
258 pp_tree_identifier (pp
, DECL_NAME (node
));
260 if ((flags
& TDF_UID
) || DECL_NAME (node
) == NULL_TREE
)
262 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
263 pp_printf (pp
, "L.%d", (int) LABEL_DECL_UID (node
));
264 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
266 if (flags
& TDF_NOUID
)
267 pp_string (pp
, "D#xxxx");
269 pp_printf (pp
, "D#%i", DEBUG_TEMP_UID (node
));
273 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
274 if (flags
& TDF_NOUID
)
275 pp_printf (pp
, "%c.xxxx", c
);
277 pp_printf (pp
, "%c.%u", c
, DECL_UID (node
));
280 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
282 if (flags
& TDF_NOUID
)
283 pp_printf (pp
, "ptD.xxxx");
285 pp_printf (pp
, "ptD.%u", DECL_PT_UID (node
));
289 /* Like the above, but used for pretty printing function calls. */
292 dump_function_name (pretty_printer
*pp
, tree node
, int flags
)
294 if (CONVERT_EXPR_P (node
))
295 node
= TREE_OPERAND (node
, 0);
296 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
297 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
299 dump_decl_name (pp
, node
, flags
);
302 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
303 FLAGS are as in dump_generic_node. */
306 dump_function_declaration (pretty_printer
*pp
, tree node
,
309 bool wrote_arg
= false;
315 /* Print the argument types. */
316 arg
= TYPE_ARG_TYPES (node
);
317 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
325 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
326 arg
= TREE_CHAIN (arg
);
329 /* Drop the trailing void_type_node if we had any previous argument. */
330 if (arg
== void_list_node
&& !wrote_arg
)
331 pp_string (pp
, "void");
332 /* Properly dump vararg function types. */
333 else if (!arg
&& wrote_arg
)
334 pp_string (pp
, ", ...");
335 /* Avoid printing any arg for unprototyped functions. */
340 /* Dump the domain associated with an array. */
343 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, int flags
)
345 pp_left_bracket (pp
);
348 tree min
= TYPE_MIN_VALUE (domain
);
349 tree max
= TYPE_MAX_VALUE (domain
);
352 && integer_zerop (min
)
353 && tree_fits_shwi_p (max
))
354 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
358 dump_generic_node (pp
, min
, spc
, flags
, false);
361 dump_generic_node (pp
, max
, spc
, flags
, false);
365 pp_string (pp
, "<unknown>");
366 pp_right_bracket (pp
);
370 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
371 dump_generic_node. */
374 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, int flags
)
378 switch (OMP_CLAUSE_CODE (clause
))
380 case OMP_CLAUSE_PRIVATE
:
383 case OMP_CLAUSE_SHARED
:
386 case OMP_CLAUSE_FIRSTPRIVATE
:
387 name
= "firstprivate";
389 case OMP_CLAUSE_LASTPRIVATE
:
390 name
= "lastprivate";
392 case OMP_CLAUSE_COPYIN
:
395 case OMP_CLAUSE_COPYPRIVATE
:
396 name
= "copyprivate";
398 case OMP_CLAUSE_UNIFORM
:
401 case OMP_CLAUSE_USE_DEVICE_PTR
:
402 name
= "use_device_ptr";
404 case OMP_CLAUSE_IS_DEVICE_PTR
:
405 name
= "is_device_ptr";
407 case OMP_CLAUSE__LOOPTEMP_
:
410 case OMP_CLAUSE_DEVICE_RESIDENT
:
411 name
= "device_resident";
413 case OMP_CLAUSE_TO_DECLARE
:
416 case OMP_CLAUSE_LINK
:
420 pp_string (pp
, name
);
422 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
427 case OMP_CLAUSE_REDUCTION
:
428 pp_string (pp
, "reduction(");
429 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
432 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
435 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
441 pp_string (pp
, "if(");
442 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
444 case ERROR_MARK
: break;
445 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
446 case OMP_TASK
: pp_string (pp
, "task:"); break;
447 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
448 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
449 case OMP_TARGET
: pp_string (pp
, "target:"); break;
450 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
451 case OMP_TARGET_ENTER_DATA
:
452 pp_string (pp
, "target enter data:"); break;
453 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
454 default: gcc_unreachable ();
456 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
461 case OMP_CLAUSE_NUM_THREADS
:
462 pp_string (pp
, "num_threads(");
463 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
468 case OMP_CLAUSE__CILK_FOR_COUNT_
:
469 pp_string (pp
, "_Cilk_for_count_(");
470 dump_generic_node (pp
, OMP_CLAUSE_OPERAND (clause
, 0),
475 case OMP_CLAUSE_NOWAIT
:
476 pp_string (pp
, "nowait");
478 case OMP_CLAUSE_ORDERED
:
479 pp_string (pp
, "ordered");
480 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
483 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
489 case OMP_CLAUSE_DEFAULT
:
490 pp_string (pp
, "default(");
491 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
493 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
495 case OMP_CLAUSE_DEFAULT_SHARED
:
496 pp_string (pp
, "shared");
498 case OMP_CLAUSE_DEFAULT_NONE
:
499 pp_string (pp
, "none");
501 case OMP_CLAUSE_DEFAULT_PRIVATE
:
502 pp_string (pp
, "private");
504 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
505 pp_string (pp
, "firstprivate");
513 case OMP_CLAUSE_SCHEDULE
:
514 pp_string (pp
, "schedule(");
515 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
516 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
517 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
519 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
520 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
521 pp_string (pp
, "monotonic");
523 pp_string (pp
, "nonmonotonic");
524 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
529 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
530 pp_string (pp
, "simd:");
532 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
534 case OMP_CLAUSE_SCHEDULE_STATIC
:
535 pp_string (pp
, "static");
537 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
538 pp_string (pp
, "dynamic");
540 case OMP_CLAUSE_SCHEDULE_GUIDED
:
541 pp_string (pp
, "guided");
543 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
544 pp_string (pp
, "runtime");
546 case OMP_CLAUSE_SCHEDULE_AUTO
:
547 pp_string (pp
, "auto");
549 case OMP_CLAUSE_SCHEDULE_CILKFOR
:
550 pp_string (pp
, "cilk-for grain");
555 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
558 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
564 case OMP_CLAUSE_UNTIED
:
565 pp_string (pp
, "untied");
568 case OMP_CLAUSE_COLLAPSE
:
569 pp_string (pp
, "collapse(");
570 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
575 case OMP_CLAUSE_FINAL
:
576 pp_string (pp
, "final(");
577 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
582 case OMP_CLAUSE_MERGEABLE
:
583 pp_string (pp
, "mergeable");
586 case OMP_CLAUSE_LINEAR
:
587 pp_string (pp
, "linear(");
588 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
590 case OMP_CLAUSE_LINEAR_DEFAULT
:
592 case OMP_CLAUSE_LINEAR_REF
:
593 pp_string (pp
, "ref(");
595 case OMP_CLAUSE_LINEAR_VAL
:
596 pp_string (pp
, "val(");
598 case OMP_CLAUSE_LINEAR_UVAL
:
599 pp_string (pp
, "uval(");
604 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
606 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
609 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
614 case OMP_CLAUSE_ALIGNED
:
615 pp_string (pp
, "aligned(");
616 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
618 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
621 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
627 case OMP_CLAUSE_DEPEND
:
628 pp_string (pp
, "depend(");
629 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
631 case OMP_CLAUSE_DEPEND_IN
:
632 pp_string (pp
, "in");
634 case OMP_CLAUSE_DEPEND_OUT
:
635 pp_string (pp
, "out");
637 case OMP_CLAUSE_DEPEND_INOUT
:
638 pp_string (pp
, "inout");
640 case OMP_CLAUSE_DEPEND_SOURCE
:
641 pp_string (pp
, "source)");
643 case OMP_CLAUSE_DEPEND_SINK
:
644 pp_string (pp
, "sink:");
645 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
646 if (TREE_CODE (t
) == TREE_LIST
)
648 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
649 if (TREE_PURPOSE (t
) != integer_zero_node
)
651 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
655 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
669 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
675 pp_string (pp
, "map(");
676 switch (OMP_CLAUSE_MAP_KIND (clause
))
679 case GOMP_MAP_POINTER
:
680 pp_string (pp
, "alloc");
683 case GOMP_MAP_TO_PSET
:
684 pp_string (pp
, "to");
687 pp_string (pp
, "from");
689 case GOMP_MAP_TOFROM
:
690 pp_string (pp
, "tofrom");
692 case GOMP_MAP_FORCE_ALLOC
:
693 pp_string (pp
, "force_alloc");
695 case GOMP_MAP_FORCE_TO
:
696 pp_string (pp
, "force_to");
698 case GOMP_MAP_FORCE_FROM
:
699 pp_string (pp
, "force_from");
701 case GOMP_MAP_FORCE_TOFROM
:
702 pp_string (pp
, "force_tofrom");
704 case GOMP_MAP_FORCE_PRESENT
:
705 pp_string (pp
, "force_present");
707 case GOMP_MAP_DELETE
:
708 pp_string (pp
, "delete");
710 case GOMP_MAP_FORCE_DEVICEPTR
:
711 pp_string (pp
, "force_deviceptr");
713 case GOMP_MAP_ALWAYS_TO
:
714 pp_string (pp
, "always,to");
716 case GOMP_MAP_ALWAYS_FROM
:
717 pp_string (pp
, "always,from");
719 case GOMP_MAP_ALWAYS_TOFROM
:
720 pp_string (pp
, "always,tofrom");
722 case GOMP_MAP_RELEASE
:
723 pp_string (pp
, "release");
725 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
726 pp_string (pp
, "firstprivate");
728 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
729 pp_string (pp
, "firstprivate ref");
731 case GOMP_MAP_STRUCT
:
732 pp_string (pp
, "struct");
734 case GOMP_MAP_ALWAYS_POINTER
:
735 pp_string (pp
, "always_pointer");
737 case GOMP_MAP_DEVICE_RESIDENT
:
738 pp_string (pp
, "device_resident");
741 pp_string (pp
, "link");
747 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
750 if (OMP_CLAUSE_SIZE (clause
))
752 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
753 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
755 case GOMP_MAP_POINTER
:
756 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
757 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
758 case GOMP_MAP_ALWAYS_POINTER
:
759 pp_string (pp
, " [pointer assign, bias: ");
761 case GOMP_MAP_TO_PSET
:
762 pp_string (pp
, " [pointer set, len: ");
765 pp_string (pp
, " [len: ");
768 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
770 pp_right_bracket (pp
);
775 case OMP_CLAUSE_FROM
:
776 pp_string (pp
, "from(");
777 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
779 goto print_clause_size
;
782 pp_string (pp
, "to(");
783 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
785 goto print_clause_size
;
787 case OMP_CLAUSE__CACHE_
:
789 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
791 goto print_clause_size
;
793 case OMP_CLAUSE_NUM_TEAMS
:
794 pp_string (pp
, "num_teams(");
795 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
800 case OMP_CLAUSE_THREAD_LIMIT
:
801 pp_string (pp
, "thread_limit(");
802 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
807 case OMP_CLAUSE_DEVICE
:
808 pp_string (pp
, "device(");
809 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
814 case OMP_CLAUSE_DIST_SCHEDULE
:
815 pp_string (pp
, "dist_schedule(static");
816 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
819 dump_generic_node (pp
,
820 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
826 case OMP_CLAUSE_PROC_BIND
:
827 pp_string (pp
, "proc_bind(");
828 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
830 case OMP_CLAUSE_PROC_BIND_MASTER
:
831 pp_string (pp
, "master");
833 case OMP_CLAUSE_PROC_BIND_CLOSE
:
834 pp_string (pp
, "close");
836 case OMP_CLAUSE_PROC_BIND_SPREAD
:
837 pp_string (pp
, "spread");
845 case OMP_CLAUSE_SAFELEN
:
846 pp_string (pp
, "safelen(");
847 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
852 case OMP_CLAUSE_SIMDLEN
:
853 pp_string (pp
, "simdlen(");
854 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
859 case OMP_CLAUSE_PRIORITY
:
860 pp_string (pp
, "priority(");
861 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
866 case OMP_CLAUSE_GRAINSIZE
:
867 pp_string (pp
, "grainsize(");
868 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
873 case OMP_CLAUSE_NUM_TASKS
:
874 pp_string (pp
, "num_tasks(");
875 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
880 case OMP_CLAUSE_HINT
:
881 pp_string (pp
, "hint(");
882 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
887 case OMP_CLAUSE_DEFAULTMAP
:
888 pp_string (pp
, "defaultmap(tofrom:scalar)");
891 case OMP_CLAUSE__SIMDUID_
:
892 pp_string (pp
, "_simduid_(");
893 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
898 case OMP_CLAUSE_GANG
:
899 pp_string (pp
, "gang");
900 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
902 pp_string (pp
, "(num: ");
903 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
906 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
908 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
912 pp_string (pp
, "static:");
913 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
914 == integer_minus_one_node
)
915 pp_character (pp
, '*');
917 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
920 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
921 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
925 case OMP_CLAUSE_ASYNC
:
926 pp_string (pp
, "async");
927 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
929 pp_character(pp
, '(');
930 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
932 pp_character(pp
, ')');
936 case OMP_CLAUSE_AUTO
:
938 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
941 case OMP_CLAUSE_WAIT
:
942 pp_string (pp
, "wait(");
943 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
945 pp_character(pp
, ')');
948 case OMP_CLAUSE_WORKER
:
949 pp_string (pp
, "worker");
950 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
953 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
959 case OMP_CLAUSE_VECTOR
:
960 pp_string (pp
, "vector");
961 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
964 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
970 case OMP_CLAUSE_NUM_GANGS
:
971 pp_string (pp
, "num_gangs(");
972 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
974 pp_character (pp
, ')');
977 case OMP_CLAUSE_NUM_WORKERS
:
978 pp_string (pp
, "num_workers(");
979 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
981 pp_character (pp
, ')');
984 case OMP_CLAUSE_VECTOR_LENGTH
:
985 pp_string (pp
, "vector_length(");
986 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
988 pp_character (pp
, ')');
991 case OMP_CLAUSE_INBRANCH
:
992 pp_string (pp
, "inbranch");
994 case OMP_CLAUSE_NOTINBRANCH
:
995 pp_string (pp
, "notinbranch");
998 pp_string (pp
, "for");
1000 case OMP_CLAUSE_PARALLEL
:
1001 pp_string (pp
, "parallel");
1003 case OMP_CLAUSE_SECTIONS
:
1004 pp_string (pp
, "sections");
1006 case OMP_CLAUSE_TASKGROUP
:
1007 pp_string (pp
, "taskgroup");
1009 case OMP_CLAUSE_NOGROUP
:
1010 pp_string (pp
, "nogroup");
1012 case OMP_CLAUSE_THREADS
:
1013 pp_string (pp
, "threads");
1015 case OMP_CLAUSE_SIMD
:
1016 pp_string (pp
, "simd");
1018 case OMP_CLAUSE_INDEPENDENT
:
1019 pp_string (pp
, "independent");
1021 case OMP_CLAUSE_TILE
:
1022 pp_string (pp
, "tile(");
1023 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1025 pp_right_paren (pp
);
1028 case OMP_CLAUSE__GRIDDIM_
:
1029 pp_string (pp
, "_griddim_(");
1030 pp_unsigned_wide_integer (pp
, OMP_CLAUSE__GRIDDIM__DIMENSION (clause
));
1032 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__SIZE (clause
), spc
, flags
,
1035 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__GROUP (clause
), spc
, flags
,
1037 pp_right_paren (pp
);
1041 /* Should never happen. */
1042 dump_generic_node (pp
, clause
, spc
, flags
, false);
1048 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1049 dump_generic_node. */
1052 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, int flags
)
1060 dump_omp_clause (pp
, clause
, spc
, flags
);
1061 clause
= OMP_CLAUSE_CHAIN (clause
);
1069 /* Dump location LOC to PP. */
1072 dump_location (pretty_printer
*pp
, location_t loc
)
1074 expanded_location xloc
= expand_location (loc
);
1076 pp_left_bracket (pp
);
1079 pp_string (pp
, xloc
.file
);
1080 pp_string (pp
, ":");
1082 pp_decimal_int (pp
, xloc
.line
);
1084 pp_decimal_int (pp
, xloc
.column
);
1085 pp_string (pp
, "] ");
1089 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1090 dump_generic_node. */
1093 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, int flags
)
1097 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1099 if (flags
& TDF_ADDRESS
)
1100 pp_printf (pp
, "[%p] ", (void *) block
);
1102 if (BLOCK_ABSTRACT (block
))
1103 pp_string (pp
, "[abstract] ");
1105 if (TREE_ASM_WRITTEN (block
))
1106 pp_string (pp
, "[written] ");
1108 if (flags
& TDF_SLIM
)
1111 if (BLOCK_SOURCE_LOCATION (block
))
1112 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1114 newline_and_indent (pp
, spc
+ 2);
1116 if (BLOCK_SUPERCONTEXT (block
))
1118 pp_string (pp
, "SUPERCONTEXT: ");
1119 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1120 flags
| TDF_SLIM
, false);
1121 newline_and_indent (pp
, spc
+ 2);
1124 if (BLOCK_SUBBLOCKS (block
))
1126 pp_string (pp
, "SUBBLOCKS: ");
1127 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1129 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1132 newline_and_indent (pp
, spc
+ 2);
1135 if (BLOCK_CHAIN (block
))
1137 pp_string (pp
, "SIBLINGS: ");
1138 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1140 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1143 newline_and_indent (pp
, spc
+ 2);
1146 if (BLOCK_VARS (block
))
1148 pp_string (pp
, "VARS: ");
1149 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1151 dump_generic_node (pp
, t
, 0, flags
, false);
1154 newline_and_indent (pp
, spc
+ 2);
1157 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1160 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1162 pp_string (pp
, "NONLOCALIZED_VARS: ");
1163 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1165 dump_generic_node (pp
, t
, 0, flags
, false);
1168 newline_and_indent (pp
, spc
+ 2);
1171 if (BLOCK_ABSTRACT_ORIGIN (block
))
1173 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1174 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1175 flags
| TDF_SLIM
, false);
1176 newline_and_indent (pp
, spc
+ 2);
1179 if (BLOCK_FRAGMENT_ORIGIN (block
))
1181 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1182 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1183 flags
| TDF_SLIM
, false);
1184 newline_and_indent (pp
, spc
+ 2);
1187 if (BLOCK_FRAGMENT_CHAIN (block
))
1189 pp_string (pp
, "FRAGMENT_CHAIN: ");
1190 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1192 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1195 newline_and_indent (pp
, spc
+ 2);
1200 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1201 indent. FLAGS specifies details to show in the dump (see TDF_* in
1202 dumpfile.h). If IS_STMT is true, the object printed is considered
1203 to be a statement and it is terminated by ';' if appropriate. */
1206 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, int flags
,
1213 enum tree_code code
;
1215 if (node
== NULL_TREE
)
1218 is_expr
= EXPR_P (node
);
1220 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1221 pp_printf (pp
, "<&%p> ", (void *)node
);
1223 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1224 dump_location (pp
, EXPR_LOCATION (node
));
1226 code
= TREE_CODE (node
);
1230 pp_string (pp
, "<<< error >>>");
1233 case IDENTIFIER_NODE
:
1234 pp_tree_identifier (pp
, node
);
1238 while (node
&& node
!= error_mark_node
)
1240 if (TREE_PURPOSE (node
))
1242 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1245 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1246 node
= TREE_CHAIN (node
);
1247 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1256 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1262 if (TREE_VEC_LENGTH (node
) > 0)
1264 size_t len
= TREE_VEC_LENGTH (node
);
1265 for (i
= 0; i
< len
- 1; i
++)
1267 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1272 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1279 case POINTER_BOUNDS_TYPE
:
1282 case FIXED_POINT_TYPE
:
1288 unsigned int quals
= TYPE_QUALS (node
);
1289 enum tree_code_class tclass
;
1291 if (quals
& TYPE_QUAL_ATOMIC
)
1292 pp_string (pp
, "atomic ");
1293 if (quals
& TYPE_QUAL_CONST
)
1294 pp_string (pp
, "const ");
1295 else if (quals
& TYPE_QUAL_VOLATILE
)
1296 pp_string (pp
, "volatile ");
1297 else if (quals
& TYPE_QUAL_RESTRICT
)
1298 pp_string (pp
, "restrict ");
1300 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1302 pp_string (pp
, "<address-space-");
1303 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1304 pp_string (pp
, "> ");
1307 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1309 if (tclass
== tcc_declaration
)
1311 if (DECL_NAME (node
))
1312 dump_decl_name (pp
, node
, flags
);
1314 pp_string (pp
, "<unnamed type decl>");
1316 else if (tclass
== tcc_type
)
1318 if (TYPE_NAME (node
))
1320 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1321 pp_tree_identifier (pp
, TYPE_NAME (node
));
1322 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1323 && DECL_NAME (TYPE_NAME (node
)))
1324 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1326 pp_string (pp
, "<unnamed type>");
1328 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1330 pp_string (pp
, "vector");
1332 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1333 pp_string (pp
, ") ");
1334 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1336 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1338 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1339 pp_string (pp
, (TYPE_UNSIGNED (node
)
1342 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1343 pp_string (pp
, (TYPE_UNSIGNED (node
)
1346 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1347 pp_string (pp
, (TYPE_UNSIGNED (node
)
1350 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1351 pp_string (pp
, (TYPE_UNSIGNED (node
)
1354 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1355 pp_string (pp
, (TYPE_UNSIGNED (node
)
1356 ? "unsigned long long"
1357 : "signed long long"));
1358 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1359 && exact_log2 (TYPE_PRECISION (node
)) != -1)
1361 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1362 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1363 pp_string (pp
, "_t");
1367 pp_string (pp
, (TYPE_UNSIGNED (node
)
1368 ? "<unnamed-unsigned:"
1369 : "<unnamed-signed:"));
1370 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1374 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1376 pp_string (pp
, "__complex__ ");
1377 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1379 else if (TREE_CODE (node
) == REAL_TYPE
)
1381 pp_string (pp
, "<float:");
1382 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1385 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1387 pp_string (pp
, "<fixed-point-");
1388 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1389 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1392 else if (TREE_CODE (node
) == VOID_TYPE
)
1393 pp_string (pp
, "void");
1395 pp_string (pp
, "<unnamed type>");
1401 case REFERENCE_TYPE
:
1402 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1404 if (TREE_TYPE (node
) == NULL
)
1406 pp_string (pp
, str
);
1407 pp_string (pp
, "<null type>");
1409 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1411 tree fnode
= TREE_TYPE (node
);
1413 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1416 pp_string (pp
, str
);
1417 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1418 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1419 else if (flags
& TDF_NOUID
)
1420 pp_printf (pp
, "<Txxxx>");
1422 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1424 pp_right_paren (pp
);
1425 dump_function_declaration (pp
, fnode
, spc
, flags
);
1429 unsigned int quals
= TYPE_QUALS (node
);
1431 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1433 pp_string (pp
, str
);
1435 if (quals
& TYPE_QUAL_CONST
)
1436 pp_string (pp
, " const");
1437 if (quals
& TYPE_QUAL_VOLATILE
)
1438 pp_string (pp
, " volatile");
1439 if (quals
& TYPE_QUAL_RESTRICT
)
1440 pp_string (pp
, " restrict");
1442 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1444 pp_string (pp
, " <address-space-");
1445 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1449 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1450 pp_string (pp
, " {ref-all}");
1460 if (integer_zerop (TREE_OPERAND (node
, 1))
1461 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1462 infer them and MEM_ATTR caching will share MEM_REFs
1463 with differently-typed op0s. */
1464 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1465 /* Released SSA_NAMES have no TREE_TYPE. */
1466 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1467 /* Same pointer types, but ignoring POINTER_TYPE vs.
1469 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1470 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1471 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1472 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1473 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1474 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1475 /* Same value types ignoring qualifiers. */
1476 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1477 == TYPE_MAIN_VARIANT
1478 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1479 && (!(flags
& TDF_ALIAS
)
1480 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1482 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1485 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1489 dump_generic_node (pp
,
1490 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1497 pp_string (pp
, "MEM[");
1499 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1500 dump_generic_node (pp
, ptype
,
1501 spc
, flags
| TDF_SLIM
, false);
1502 pp_right_paren (pp
);
1503 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1505 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1507 pp_string (pp
, " + ");
1508 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1511 if ((flags
& TDF_ALIAS
)
1512 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1514 pp_string (pp
, " clique ");
1515 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1516 pp_string (pp
, " base ");
1517 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1519 pp_right_bracket (pp
);
1524 case TARGET_MEM_REF
:
1526 const char *sep
= "";
1529 pp_string (pp
, "MEM[");
1531 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1533 pp_string (pp
, sep
);
1535 pp_string (pp
, "symbol: ");
1536 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1541 pp_string (pp
, sep
);
1543 pp_string (pp
, "base: ");
1544 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1546 tmp
= TMR_INDEX2 (node
);
1549 pp_string (pp
, sep
);
1551 pp_string (pp
, "base: ");
1552 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1554 tmp
= TMR_INDEX (node
);
1557 pp_string (pp
, sep
);
1559 pp_string (pp
, "index: ");
1560 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1562 tmp
= TMR_STEP (node
);
1565 pp_string (pp
, sep
);
1567 pp_string (pp
, "step: ");
1568 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1570 tmp
= TMR_OFFSET (node
);
1573 pp_string (pp
, sep
);
1575 pp_string (pp
, "offset: ");
1576 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1578 pp_right_bracket (pp
);
1586 /* Print the innermost component type. */
1587 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1588 tmp
= TREE_TYPE (tmp
))
1590 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1592 /* Print the dimensions. */
1593 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1594 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1600 case QUAL_UNION_TYPE
:
1602 unsigned int quals
= TYPE_QUALS (node
);
1604 if (quals
& TYPE_QUAL_ATOMIC
)
1605 pp_string (pp
, "atomic ");
1606 if (quals
& TYPE_QUAL_CONST
)
1607 pp_string (pp
, "const ");
1608 if (quals
& TYPE_QUAL_VOLATILE
)
1609 pp_string (pp
, "volatile ");
1611 /* Print the name of the structure. */
1612 if (TREE_CODE (node
) == RECORD_TYPE
)
1613 pp_string (pp
, "struct ");
1614 else if (TREE_CODE (node
) == UNION_TYPE
)
1615 pp_string (pp
, "union ");
1617 if (TYPE_NAME (node
))
1618 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1619 else if (!(flags
& TDF_SLIM
))
1620 /* FIXME: If we eliminate the 'else' above and attempt
1621 to show the fields for named types, we may get stuck
1622 following a cycle of pointers to structs. The alleged
1623 self-reference check in print_struct_decl will not detect
1624 cycles involving more than one pointer or struct type. */
1625 print_struct_decl (pp
, node
, spc
, flags
);
1634 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
1636 /* In the case of a pointer, one may want to divide by the
1637 size of the pointed-to type. Unfortunately, this not
1638 straightforward. The C front-end maps expressions
1643 in such a way that the two INTEGER_CST nodes for "5" have
1644 different values but identical types. In the latter
1645 case, the 5 is multiplied by sizeof (int) in c-common.c
1646 (pointer_int_sum) to convert it to a byte address, and
1647 yet the type of the node is left unchanged. Argh. What
1648 is consistent though is that the number value corresponds
1649 to bytes (UNITS) offset.
1651 NB: Neither of the following divisors can be trivially
1652 used to recover the original literal:
1654 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1655 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1656 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1657 pp_string (pp
, "B"); /* pseudo-unit */
1659 else if (tree_fits_shwi_p (node
))
1660 pp_wide_integer (pp
, tree_to_shwi (node
));
1661 else if (tree_fits_uhwi_p (node
))
1662 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1665 wide_int val
= node
;
1667 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1672 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
1673 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
1675 if (TREE_OVERFLOW (node
))
1676 pp_string (pp
, "(OVF)");
1680 /* Code copied from print_node. */
1683 if (TREE_OVERFLOW (node
))
1684 pp_string (pp
, " overflow");
1686 d
= TREE_REAL_CST (node
);
1687 if (REAL_VALUE_ISINF (d
))
1688 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1689 else if (REAL_VALUE_ISNAN (d
))
1690 pp_string (pp
, " Nan");
1694 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1695 pp_string (pp
, string
);
1703 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1704 pp_string (pp
, string
);
1709 pp_string (pp
, "__complex__ (");
1710 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
1711 pp_string (pp
, ", ");
1712 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
1713 pp_right_paren (pp
);
1717 pp_string (pp
, "\"");
1718 pretty_print_string (pp
, TREE_STRING_POINTER (node
));
1719 pp_string (pp
, "\"");
1725 pp_string (pp
, "{ ");
1726 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1729 pp_string (pp
, ", ");
1730 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
1733 pp_string (pp
, " }");
1739 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1741 if (TREE_CODE (node
) == METHOD_TYPE
)
1743 if (TYPE_METHOD_BASETYPE (node
))
1744 dump_decl_name (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1747 pp_string (pp
, "<null method basetype>");
1748 pp_colon_colon (pp
);
1750 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1751 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1752 else if (flags
& TDF_NOUID
)
1753 pp_printf (pp
, "<Txxxx>");
1755 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1756 dump_function_declaration (pp
, node
, spc
, flags
);
1761 dump_decl_name (pp
, node
, flags
);
1765 if (DECL_NAME (node
))
1766 dump_decl_name (pp
, node
, flags
);
1767 else if (LABEL_DECL_UID (node
) != -1)
1768 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
1771 if (flags
& TDF_NOUID
)
1772 pp_string (pp
, "<D.xxxx>");
1774 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
1779 if (DECL_IS_BUILTIN (node
))
1781 /* Don't print the declaration of built-in types. */
1784 if (DECL_NAME (node
))
1785 dump_decl_name (pp
, node
, flags
);
1786 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1788 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1789 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1790 && TYPE_METHODS (TREE_TYPE (node
)))
1792 /* The type is a c++ class: all structures have at least
1794 pp_string (pp
, "class ");
1795 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1800 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1801 ? "union" : "struct "));
1802 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1806 pp_string (pp
, "<anon>");
1812 case DEBUG_EXPR_DECL
:
1813 case NAMESPACE_DECL
:
1815 dump_decl_name (pp
, node
, flags
);
1819 pp_string (pp
, "<retval>");
1823 op0
= TREE_OPERAND (node
, 0);
1826 && (TREE_CODE (op0
) == INDIRECT_REF
1827 || (TREE_CODE (op0
) == MEM_REF
1828 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1829 && integer_zerop (TREE_OPERAND (op0
, 1))
1830 /* Dump the types of INTEGER_CSTs explicitly, for we
1831 can't infer them and MEM_ATTR caching will share
1832 MEM_REFs with differently-typed op0s. */
1833 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1834 /* Released SSA_NAMES have no TREE_TYPE. */
1835 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1836 /* Same pointer types, but ignoring POINTER_TYPE vs.
1838 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1839 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1840 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1841 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1842 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1843 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1844 /* Same value types ignoring qualifiers. */
1845 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1846 == TYPE_MAIN_VARIANT
1847 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
1848 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
1850 op0
= TREE_OPERAND (op0
, 0);
1853 if (op_prio (op0
) < op_prio (node
))
1855 dump_generic_node (pp
, op0
, spc
, flags
, false);
1856 if (op_prio (op0
) < op_prio (node
))
1857 pp_right_paren (pp
);
1858 pp_string (pp
, str
);
1859 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1860 op0
= component_ref_field_offset (node
);
1861 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1863 pp_string (pp
, "{off: ");
1864 dump_generic_node (pp
, op0
, spc
, flags
, false);
1865 pp_right_brace (pp
);
1870 pp_string (pp
, "BIT_FIELD_REF <");
1871 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1872 pp_string (pp
, ", ");
1873 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1874 pp_string (pp
, ", ");
1875 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1880 case ARRAY_RANGE_REF
:
1881 op0
= TREE_OPERAND (node
, 0);
1882 if (op_prio (op0
) < op_prio (node
))
1884 dump_generic_node (pp
, op0
, spc
, flags
, false);
1885 if (op_prio (op0
) < op_prio (node
))
1886 pp_right_paren (pp
);
1887 pp_left_bracket (pp
);
1888 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1889 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1890 pp_string (pp
, " ...");
1891 pp_right_bracket (pp
);
1893 op0
= array_ref_low_bound (node
);
1894 op1
= array_ref_element_size (node
);
1896 if (!integer_zerop (op0
)
1897 || TREE_OPERAND (node
, 2)
1898 || TREE_OPERAND (node
, 3))
1900 pp_string (pp
, "{lb: ");
1901 dump_generic_node (pp
, op0
, spc
, flags
, false);
1902 pp_string (pp
, " sz: ");
1903 dump_generic_node (pp
, op1
, spc
, flags
, false);
1904 pp_right_brace (pp
);
1910 unsigned HOST_WIDE_INT ix
;
1912 bool is_struct_init
= false;
1913 bool is_array_init
= false;
1916 if (TREE_CLOBBER_P (node
))
1917 pp_string (pp
, "CLOBBER");
1918 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1919 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1920 is_struct_init
= true;
1921 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
1922 && TYPE_DOMAIN (TREE_TYPE (node
))
1923 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
1924 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
1927 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
1928 is_array_init
= true;
1929 curidx
= wi::to_widest (minv
);
1931 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1938 dump_generic_node (pp
, field
, spc
, flags
, false);
1941 else if (is_array_init
1942 && (TREE_CODE (field
) != INTEGER_CST
1943 || curidx
!= wi::to_widest (field
)))
1945 pp_left_bracket (pp
);
1946 if (TREE_CODE (field
) == RANGE_EXPR
)
1948 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
1950 pp_string (pp
, " ... ");
1951 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
1953 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
1954 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
1957 dump_generic_node (pp
, field
, spc
, flags
, false);
1958 if (TREE_CODE (field
) == INTEGER_CST
)
1959 curidx
= wi::to_widest (field
);
1960 pp_string (pp
, "]=");
1965 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1966 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1967 val
= TREE_OPERAND (val
, 0);
1968 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1969 dump_decl_name (pp
, val
, flags
);
1971 dump_generic_node (pp
, val
, spc
, flags
, false);
1972 if (ix
!= vec_safe_length (CONSTRUCTOR_ELTS (node
)) - 1)
1978 pp_right_brace (pp
);
1985 if (flags
& TDF_SLIM
)
1987 pp_string (pp
, "<COMPOUND_EXPR>");
1991 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1992 spc
, flags
, !(flags
& TDF_SLIM
));
1993 if (flags
& TDF_SLIM
)
1994 newline_and_indent (pp
, spc
);
2001 for (tp
= &TREE_OPERAND (node
, 1);
2002 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2003 tp
= &TREE_OPERAND (*tp
, 1))
2005 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2006 spc
, flags
, !(flags
& TDF_SLIM
));
2007 if (flags
& TDF_SLIM
)
2008 newline_and_indent (pp
, spc
);
2016 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2020 case STATEMENT_LIST
:
2022 tree_stmt_iterator si
;
2025 if (flags
& TDF_SLIM
)
2027 pp_string (pp
, "<STATEMENT_LIST>");
2031 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2034 newline_and_indent (pp
, spc
);
2037 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2044 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2049 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2054 pp_string (pp
, "TARGET_EXPR <");
2055 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2058 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2063 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2068 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2070 pp_string (pp
, "if (");
2071 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2072 pp_right_paren (pp
);
2073 /* The lowered cond_exprs should always be printed in full. */
2074 if (COND_EXPR_THEN (node
)
2075 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2076 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2077 && COND_EXPR_ELSE (node
)
2078 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2079 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2082 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2084 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2086 pp_string (pp
, " else ");
2087 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2091 else if (!(flags
& TDF_SLIM
))
2093 /* Output COND_EXPR_THEN. */
2094 if (COND_EXPR_THEN (node
))
2096 newline_and_indent (pp
, spc
+2);
2098 newline_and_indent (pp
, spc
+4);
2099 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2101 newline_and_indent (pp
, spc
+2);
2102 pp_right_brace (pp
);
2105 /* Output COND_EXPR_ELSE. */
2106 if (COND_EXPR_ELSE (node
)
2107 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2109 newline_and_indent (pp
, spc
);
2110 pp_string (pp
, "else");
2111 newline_and_indent (pp
, spc
+2);
2113 newline_and_indent (pp
, spc
+4);
2114 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2116 newline_and_indent (pp
, spc
+2);
2117 pp_right_brace (pp
);
2124 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2128 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2132 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2138 if (!(flags
& TDF_SLIM
))
2140 if (BIND_EXPR_VARS (node
))
2144 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2146 print_declaration (pp
, op0
, spc
+2, flags
);
2151 newline_and_indent (pp
, spc
+2);
2152 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2153 newline_and_indent (pp
, spc
);
2154 pp_right_brace (pp
);
2160 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2161 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2163 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2165 /* Print parameters. */
2170 call_expr_arg_iterator iter
;
2171 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2173 dump_generic_node (pp
, arg
, spc
, flags
, false);
2174 if (more_call_expr_args_p (&iter
))
2181 if (CALL_EXPR_VA_ARG_PACK (node
))
2183 if (call_expr_nargs (node
) > 0)
2188 pp_string (pp
, "__builtin_va_arg_pack ()");
2190 pp_right_paren (pp
);
2192 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2195 pp_string (pp
, " [static-chain: ");
2196 dump_generic_node (pp
, op1
, spc
, flags
, false);
2197 pp_right_bracket (pp
);
2200 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2201 pp_string (pp
, " [return slot optimization]");
2202 if (CALL_EXPR_TAILCALL (node
))
2203 pp_string (pp
, " [tail call]");
2206 case WITH_CLEANUP_EXPR
:
2210 case CLEANUP_POINT_EXPR
:
2211 pp_string (pp
, "<<cleanup_point ");
2212 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2213 pp_string (pp
, ">>");
2216 case PLACEHOLDER_EXPR
:
2217 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2218 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2222 /* Binary arithmetic and logic expressions. */
2223 case WIDEN_SUM_EXPR
:
2224 case WIDEN_MULT_EXPR
:
2226 case MULT_HIGHPART_EXPR
:
2228 case POINTER_PLUS_EXPR
:
2230 case TRUNC_DIV_EXPR
:
2232 case FLOOR_DIV_EXPR
:
2233 case ROUND_DIV_EXPR
:
2234 case TRUNC_MOD_EXPR
:
2236 case FLOOR_MOD_EXPR
:
2237 case ROUND_MOD_EXPR
:
2239 case EXACT_DIV_EXPR
:
2244 case WIDEN_LSHIFT_EXPR
:
2248 case TRUTH_ANDIF_EXPR
:
2249 case TRUTH_ORIF_EXPR
:
2250 case TRUTH_AND_EXPR
:
2252 case TRUTH_XOR_EXPR
:
2266 case UNORDERED_EXPR
:
2268 const char *op
= op_symbol (node
);
2269 op0
= TREE_OPERAND (node
, 0);
2270 op1
= TREE_OPERAND (node
, 1);
2272 /* When the operands are expressions with less priority,
2273 keep semantics of the tree representation. */
2274 if (op_prio (op0
) <= op_prio (node
))
2277 dump_generic_node (pp
, op0
, spc
, flags
, false);
2278 pp_right_paren (pp
);
2281 dump_generic_node (pp
, op0
, spc
, flags
, false);
2287 /* When the operands are expressions with less priority,
2288 keep semantics of the tree representation. */
2289 if (op_prio (op1
) <= op_prio (node
))
2292 dump_generic_node (pp
, op1
, spc
, flags
, false);
2293 pp_right_paren (pp
);
2296 dump_generic_node (pp
, op1
, spc
, flags
, false);
2300 /* Unary arithmetic and logic expressions. */
2303 case TRUTH_NOT_EXPR
:
2305 case PREDECREMENT_EXPR
:
2306 case PREINCREMENT_EXPR
:
2308 if (TREE_CODE (node
) == ADDR_EXPR
2309 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2310 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2311 ; /* Do not output '&' for strings and function pointers. */
2313 pp_string (pp
, op_symbol (node
));
2315 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2318 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2319 pp_right_paren (pp
);
2322 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2325 case POSTDECREMENT_EXPR
:
2326 case POSTINCREMENT_EXPR
:
2327 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2330 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2331 pp_right_paren (pp
);
2334 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2335 pp_string (pp
, op_symbol (node
));
2339 pp_string (pp
, "MIN_EXPR <");
2340 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2341 pp_string (pp
, ", ");
2342 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2347 pp_string (pp
, "MAX_EXPR <");
2348 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2349 pp_string (pp
, ", ");
2350 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2355 pp_string (pp
, "ABS_EXPR <");
2356 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2364 case ADDR_SPACE_CONVERT_EXPR
:
2365 case FIXED_CONVERT_EXPR
:
2366 case FIX_TRUNC_EXPR
:
2369 type
= TREE_TYPE (node
);
2370 op0
= TREE_OPERAND (node
, 0);
2371 if (type
!= TREE_TYPE (op0
))
2374 dump_generic_node (pp
, type
, spc
, flags
, false);
2375 pp_string (pp
, ") ");
2377 if (op_prio (op0
) < op_prio (node
))
2379 dump_generic_node (pp
, op0
, spc
, flags
, false);
2380 if (op_prio (op0
) < op_prio (node
))
2381 pp_right_paren (pp
);
2384 case VIEW_CONVERT_EXPR
:
2385 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2386 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2387 pp_string (pp
, ">(");
2388 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2389 pp_right_paren (pp
);
2393 pp_string (pp
, "((");
2394 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2395 pp_string (pp
, "))");
2398 case NON_LVALUE_EXPR
:
2399 pp_string (pp
, "NON_LVALUE_EXPR <");
2400 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2405 pp_string (pp
, "SAVE_EXPR <");
2406 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2411 pp_string (pp
, "COMPLEX_EXPR <");
2412 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2413 pp_string (pp
, ", ");
2414 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2419 pp_string (pp
, "CONJ_EXPR <");
2420 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2425 pp_string (pp
, "REALPART_EXPR <");
2426 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2431 pp_string (pp
, "IMAGPART_EXPR <");
2432 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2437 pp_string (pp
, "VA_ARG_EXPR <");
2438 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2442 case TRY_FINALLY_EXPR
:
2443 case TRY_CATCH_EXPR
:
2444 pp_string (pp
, "try");
2445 newline_and_indent (pp
, spc
+2);
2447 newline_and_indent (pp
, spc
+4);
2448 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2449 newline_and_indent (pp
, spc
+2);
2450 pp_right_brace (pp
);
2451 newline_and_indent (pp
, spc
);
2453 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2454 newline_and_indent (pp
, spc
+2);
2456 newline_and_indent (pp
, spc
+4);
2457 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2458 newline_and_indent (pp
, spc
+2);
2459 pp_right_brace (pp
);
2464 pp_string (pp
, "catch (");
2465 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2466 pp_right_paren (pp
);
2467 newline_and_indent (pp
, spc
+2);
2469 newline_and_indent (pp
, spc
+4);
2470 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2471 newline_and_indent (pp
, spc
+2);
2472 pp_right_brace (pp
);
2476 case EH_FILTER_EXPR
:
2477 pp_string (pp
, "<<<eh_filter (");
2478 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2479 pp_string (pp
, ")>>>");
2480 newline_and_indent (pp
, spc
+2);
2482 newline_and_indent (pp
, spc
+4);
2483 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2484 newline_and_indent (pp
, spc
+2);
2485 pp_right_brace (pp
);
2490 op0
= TREE_OPERAND (node
, 0);
2491 /* If this is for break or continue, don't bother printing it. */
2492 if (DECL_NAME (op0
))
2494 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2495 if (strcmp (name
, "break") == 0
2496 || strcmp (name
, "continue") == 0)
2499 dump_generic_node (pp
, op0
, spc
, flags
, false);
2501 if (DECL_NONLOCAL (op0
))
2502 pp_string (pp
, " [non-local]");
2506 pp_string (pp
, "while (1)");
2507 if (!(flags
& TDF_SLIM
))
2509 newline_and_indent (pp
, spc
+2);
2511 newline_and_indent (pp
, spc
+4);
2512 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2513 newline_and_indent (pp
, spc
+2);
2514 pp_right_brace (pp
);
2520 pp_string (pp
, "// predicted ");
2521 if (PREDICT_EXPR_OUTCOME (node
))
2522 pp_string (pp
, "likely by ");
2524 pp_string (pp
, "unlikely by ");
2525 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2526 pp_string (pp
, " predictor.");
2530 pp_string (pp
, "ANNOTATE_EXPR <");
2531 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2532 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2534 case annot_expr_ivdep_kind
:
2535 pp_string (pp
, ", ivdep");
2537 case annot_expr_no_vector_kind
:
2538 pp_string (pp
, ", no-vector");
2540 case annot_expr_vector_kind
:
2541 pp_string (pp
, ", vector");
2550 pp_string (pp
, "return");
2551 op0
= TREE_OPERAND (node
, 0);
2555 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2556 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2559 dump_generic_node (pp
, op0
, spc
, flags
, false);
2564 pp_string (pp
, "if (");
2565 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2566 pp_string (pp
, ") break");
2570 pp_string (pp
, "switch (");
2571 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2572 pp_right_paren (pp
);
2573 if (!(flags
& TDF_SLIM
))
2575 newline_and_indent (pp
, spc
+2);
2577 if (SWITCH_BODY (node
))
2579 newline_and_indent (pp
, spc
+4);
2580 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2585 tree vec
= SWITCH_LABELS (node
);
2586 size_t i
, n
= TREE_VEC_LENGTH (vec
);
2587 for (i
= 0; i
< n
; ++i
)
2589 tree elt
= TREE_VEC_ELT (vec
, i
);
2590 newline_and_indent (pp
, spc
+4);
2593 dump_generic_node (pp
, elt
, spc
+4, flags
, false);
2594 pp_string (pp
, " goto ");
2595 dump_generic_node (pp
, CASE_LABEL (elt
), spc
+4,
2600 pp_string (pp
, "case ???: goto ???;");
2603 newline_and_indent (pp
, spc
+2);
2604 pp_right_brace (pp
);
2610 op0
= GOTO_DESTINATION (node
);
2611 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2613 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2614 if (strcmp (name
, "break") == 0
2615 || strcmp (name
, "continue") == 0)
2617 pp_string (pp
, name
);
2621 pp_string (pp
, "goto ");
2622 dump_generic_node (pp
, op0
, spc
, flags
, false);
2626 pp_string (pp
, "__asm__");
2627 if (ASM_VOLATILE_P (node
))
2628 pp_string (pp
, " __volatile__");
2630 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2632 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2634 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2635 if (ASM_CLOBBERS (node
))
2638 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2640 pp_right_paren (pp
);
2643 case CASE_LABEL_EXPR
:
2644 if (CASE_LOW (node
) && CASE_HIGH (node
))
2646 pp_string (pp
, "case ");
2647 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2648 pp_string (pp
, " ... ");
2649 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2651 else if (CASE_LOW (node
))
2653 pp_string (pp
, "case ");
2654 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2657 pp_string (pp
, "default");
2662 pp_string (pp
, "OBJ_TYPE_REF(");
2663 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2665 if (!(flags
& TDF_SLIM
) && virtual_method_call_p (node
))
2667 pp_string (pp
, "(");
2668 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2669 pp_string (pp
, ")");
2671 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2673 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2674 pp_right_paren (pp
);
2678 if (SSA_NAME_IDENTIFIER (node
))
2680 if ((flags
& TDF_NOUID
)
2681 && SSA_NAME_VAR (node
)
2682 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
2683 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
2685 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2689 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2690 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2691 pp_string (pp
, "(D)");
2692 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2693 pp_string (pp
, "(ab)");
2696 case WITH_SIZE_EXPR
:
2697 pp_string (pp
, "WITH_SIZE_EXPR <");
2698 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2699 pp_string (pp
, ", ");
2700 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2705 pp_string (pp
, "ASSERT_EXPR <");
2706 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2707 pp_string (pp
, ", ");
2708 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2713 pp_string (pp
, "scev_known");
2716 case SCEV_NOT_KNOWN
:
2717 pp_string (pp
, "scev_not_known");
2720 case POLYNOMIAL_CHREC
:
2722 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2723 pp_string (pp
, ", +, ");
2724 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2725 pp_string (pp
, "}_");
2726 dump_generic_node (pp
, CHREC_VAR (node
), spc
, flags
, false);
2730 case REALIGN_LOAD_EXPR
:
2731 pp_string (pp
, "REALIGN_LOAD <");
2732 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2733 pp_string (pp
, ", ");
2734 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2735 pp_string (pp
, ", ");
2736 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2741 pp_string (pp
, " VEC_COND_EXPR < ");
2742 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2743 pp_string (pp
, " , ");
2744 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2745 pp_string (pp
, " , ");
2746 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2747 pp_string (pp
, " > ");
2751 pp_string (pp
, " VEC_PERM_EXPR < ");
2752 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2753 pp_string (pp
, " , ");
2754 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2755 pp_string (pp
, " , ");
2756 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2757 pp_string (pp
, " > ");
2761 pp_string (pp
, " DOT_PROD_EXPR < ");
2762 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2763 pp_string (pp
, ", ");
2764 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2765 pp_string (pp
, ", ");
2766 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2767 pp_string (pp
, " > ");
2770 case WIDEN_MULT_PLUS_EXPR
:
2771 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
2772 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2773 pp_string (pp
, ", ");
2774 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2775 pp_string (pp
, ", ");
2776 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2777 pp_string (pp
, " > ");
2780 case WIDEN_MULT_MINUS_EXPR
:
2781 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
2782 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2783 pp_string (pp
, ", ");
2784 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2785 pp_string (pp
, ", ");
2786 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2787 pp_string (pp
, " > ");
2791 pp_string (pp
, " FMA_EXPR < ");
2792 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2793 pp_string (pp
, ", ");
2794 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2795 pp_string (pp
, ", ");
2796 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2797 pp_string (pp
, " > ");
2801 pp_string (pp
, "#pragma acc parallel");
2802 goto dump_omp_clauses_body
;
2805 pp_string (pp
, "#pragma acc kernels");
2806 goto dump_omp_clauses_body
;
2809 pp_string (pp
, "#pragma acc data");
2810 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2813 case OACC_HOST_DATA
:
2814 pp_string (pp
, "#pragma acc host_data");
2815 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2819 pp_string (pp
, "#pragma acc declare");
2820 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2824 pp_string (pp
, "#pragma acc update");
2825 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2828 case OACC_ENTER_DATA
:
2829 pp_string (pp
, "#pragma acc enter data");
2830 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2833 case OACC_EXIT_DATA
:
2834 pp_string (pp
, "#pragma acc exit data");
2835 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2839 pp_string (pp
, "#pragma acc cache");
2840 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2844 pp_string (pp
, "#pragma omp parallel");
2845 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2848 dump_omp_clauses_body
:
2849 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2853 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2855 newline_and_indent (pp
, spc
+ 2);
2857 newline_and_indent (pp
, spc
+ 4);
2858 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2859 newline_and_indent (pp
, spc
+ 2);
2860 pp_right_brace (pp
);
2866 pp_string (pp
, "#pragma omp task");
2867 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2871 pp_string (pp
, "#pragma omp for");
2875 pp_string (pp
, "#pragma omp simd");
2879 pp_string (pp
, "#pragma simd");
2883 /* This label points one line after dumping the clauses.
2884 For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2885 parameters are printed out. */
2886 goto dump_omp_loop_cilk_for
;
2888 case OMP_DISTRIBUTE
:
2889 pp_string (pp
, "#pragma omp distribute");
2893 pp_string (pp
, "#pragma omp taskloop");
2897 pp_string (pp
, "#pragma acc loop");
2901 pp_string (pp
, "#pragma omp teams");
2902 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
2905 case OMP_TARGET_DATA
:
2906 pp_string (pp
, "#pragma omp target data");
2907 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
2910 case OMP_TARGET_ENTER_DATA
:
2911 pp_string (pp
, "#pragma omp target enter data");
2912 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2916 case OMP_TARGET_EXIT_DATA
:
2917 pp_string (pp
, "#pragma omp target exit data");
2918 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2923 pp_string (pp
, "#pragma omp target");
2924 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
2927 case OMP_TARGET_UPDATE
:
2928 pp_string (pp
, "#pragma omp target update");
2929 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
2934 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2936 dump_omp_loop_cilk_for
:
2937 if (!(flags
& TDF_SLIM
))
2941 if (OMP_FOR_PRE_BODY (node
))
2943 if (TREE_CODE (node
) == CILK_FOR
)
2944 pp_string (pp
, " ");
2946 newline_and_indent (pp
, spc
+ 2);
2949 newline_and_indent (pp
, spc
);
2950 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
2953 if (OMP_FOR_INIT (node
))
2956 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
2959 if (TREE_CODE (node
) != CILK_FOR
|| OMP_FOR_PRE_BODY (node
))
2960 newline_and_indent (pp
, spc
);
2961 if (TREE_CODE (node
) == CILK_FOR
)
2962 pp_string (pp
, "_Cilk_for (");
2964 pp_string (pp
, "for (");
2965 dump_generic_node (pp
,
2966 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
2968 pp_string (pp
, "; ");
2969 dump_generic_node (pp
,
2970 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
2972 pp_string (pp
, "; ");
2973 dump_generic_node (pp
,
2974 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
2976 pp_right_paren (pp
);
2978 if (TREE_CODE (node
) == CILK_FOR
)
2979 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2981 if (OMP_FOR_BODY (node
))
2983 newline_and_indent (pp
, spc
+ 2);
2985 newline_and_indent (pp
, spc
+ 4);
2986 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
2988 newline_and_indent (pp
, spc
+ 2);
2989 pp_right_brace (pp
);
2991 if (OMP_FOR_INIT (node
))
2992 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
2993 if (OMP_FOR_PRE_BODY (node
))
2996 newline_and_indent (pp
, spc
+ 2);
2997 pp_right_brace (pp
);
3004 pp_string (pp
, "#pragma omp sections");
3005 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3009 pp_string (pp
, "#pragma omp section");
3013 pp_string (pp
, "#pragma omp master");
3017 pp_string (pp
, "#pragma omp taskgroup");
3021 pp_string (pp
, "#pragma omp ordered");
3022 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3026 pp_string (pp
, "#pragma omp critical");
3027 if (OMP_CRITICAL_NAME (node
))
3031 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3033 pp_right_paren (pp
);
3035 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3039 pp_string (pp
, "#pragma omp atomic");
3040 if (OMP_ATOMIC_SEQ_CST (node
))
3041 pp_string (pp
, " seq_cst");
3042 newline_and_indent (pp
, spc
+ 2);
3043 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3047 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3050 case OMP_ATOMIC_READ
:
3051 pp_string (pp
, "#pragma omp atomic read");
3052 if (OMP_ATOMIC_SEQ_CST (node
))
3053 pp_string (pp
, " seq_cst");
3054 newline_and_indent (pp
, spc
+ 2);
3055 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3059 case OMP_ATOMIC_CAPTURE_OLD
:
3060 case OMP_ATOMIC_CAPTURE_NEW
:
3061 pp_string (pp
, "#pragma omp atomic capture");
3062 if (OMP_ATOMIC_SEQ_CST (node
))
3063 pp_string (pp
, " seq_cst");
3064 newline_and_indent (pp
, spc
+ 2);
3065 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3069 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3073 pp_string (pp
, "#pragma omp single");
3074 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3078 dump_omp_clause (pp
, node
, spc
, flags
);
3082 case TRANSACTION_EXPR
:
3083 if (TRANSACTION_EXPR_OUTER (node
))
3084 pp_string (pp
, "__transaction_atomic [[outer]]");
3085 else if (TRANSACTION_EXPR_RELAXED (node
))
3086 pp_string (pp
, "__transaction_relaxed");
3088 pp_string (pp
, "__transaction_atomic");
3089 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3091 newline_and_indent (pp
, spc
);
3093 newline_and_indent (pp
, spc
+ 2);
3094 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3095 spc
+ 2, flags
, false);
3096 newline_and_indent (pp
, spc
);
3097 pp_right_brace (pp
);
3102 case REDUC_MAX_EXPR
:
3103 pp_string (pp
, " REDUC_MAX_EXPR < ");
3104 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3105 pp_string (pp
, " > ");
3108 case REDUC_MIN_EXPR
:
3109 pp_string (pp
, " REDUC_MIN_EXPR < ");
3110 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3111 pp_string (pp
, " > ");
3114 case REDUC_PLUS_EXPR
:
3115 pp_string (pp
, " REDUC_PLUS_EXPR < ");
3116 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3117 pp_string (pp
, " > ");
3120 case VEC_WIDEN_MULT_HI_EXPR
:
3121 case VEC_WIDEN_MULT_LO_EXPR
:
3122 case VEC_WIDEN_MULT_EVEN_EXPR
:
3123 case VEC_WIDEN_MULT_ODD_EXPR
:
3124 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3125 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3127 for (str
= get_tree_code_name (code
); *str
; str
++)
3128 pp_character (pp
, TOUPPER (*str
));
3129 pp_string (pp
, " < ");
3130 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3131 pp_string (pp
, ", ");
3132 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3133 pp_string (pp
, " > ");
3136 case VEC_UNPACK_HI_EXPR
:
3137 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3138 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3139 pp_string (pp
, " > ");
3142 case VEC_UNPACK_LO_EXPR
:
3143 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3144 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3145 pp_string (pp
, " > ");
3148 case VEC_UNPACK_FLOAT_HI_EXPR
:
3149 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3150 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3151 pp_string (pp
, " > ");
3154 case VEC_UNPACK_FLOAT_LO_EXPR
:
3155 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3156 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3157 pp_string (pp
, " > ");
3160 case VEC_PACK_TRUNC_EXPR
:
3161 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3162 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3163 pp_string (pp
, ", ");
3164 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3165 pp_string (pp
, " > ");
3168 case VEC_PACK_SAT_EXPR
:
3169 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3170 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3171 pp_string (pp
, ", ");
3172 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3173 pp_string (pp
, " > ");
3176 case VEC_PACK_FIX_TRUNC_EXPR
:
3177 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3178 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3179 pp_string (pp
, ", ");
3180 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3181 pp_string (pp
, " > ");
3185 dump_block_node (pp
, node
, spc
, flags
);
3188 case CILK_SPAWN_STMT
:
3189 pp_string (pp
, "_Cilk_spawn ");
3190 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3193 case CILK_SYNC_STMT
:
3194 pp_string (pp
, "_Cilk_sync");
3201 if (is_stmt
&& is_expr
)
3207 /* Print the declaration of a variable. */
3210 print_declaration (pretty_printer
*pp
, tree t
, int spc
, int flags
)
3214 if (TREE_CODE(t
) == NAMELIST_DECL
)
3216 pp_string(pp
, "namelist ");
3217 dump_decl_name (pp
, t
, flags
);
3222 if (TREE_CODE (t
) == TYPE_DECL
)
3223 pp_string (pp
, "typedef ");
3225 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3226 pp_string (pp
, "register ");
3228 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3229 pp_string (pp
, "extern ");
3230 else if (TREE_STATIC (t
))
3231 pp_string (pp
, "static ");
3233 /* Print the type and name. */
3234 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3238 /* Print array's type. */
3239 tmp
= TREE_TYPE (t
);
3240 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3241 tmp
= TREE_TYPE (tmp
);
3242 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3244 /* Print variable's name. */
3246 dump_generic_node (pp
, t
, spc
, flags
, false);
3248 /* Print the dimensions. */
3249 tmp
= TREE_TYPE (t
);
3250 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3252 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3253 tmp
= TREE_TYPE (tmp
);
3256 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3258 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3260 dump_decl_name (pp
, t
, flags
);
3261 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3265 /* Print type declaration. */
3266 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3268 /* Print variable's name. */
3270 dump_generic_node (pp
, t
, spc
, flags
, false);
3273 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
3275 pp_string (pp
, " __asm__ ");
3277 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3278 pp_right_paren (pp
);
3281 /* The initial value of a function serves to determine whether the function
3282 is declared or defined. So the following does not apply to function
3284 if (TREE_CODE (t
) != FUNCTION_DECL
)
3286 /* Print the initial value. */
3287 if (DECL_INITIAL (t
))
3292 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3296 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
3298 pp_string (pp
, " [value-expr: ");
3299 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3300 pp_right_bracket (pp
);
3307 /* Prints a structure: name, fields, and methods.
3308 FIXME: Still incomplete. */
3311 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
, int flags
)
3313 /* Print the name of the structure. */
3314 if (TYPE_NAME (node
))
3317 if (TREE_CODE (node
) == RECORD_TYPE
)
3318 pp_string (pp
, "struct ");
3319 else if ((TREE_CODE (node
) == UNION_TYPE
3320 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3321 pp_string (pp
, "union ");
3323 dump_generic_node (pp
, TYPE_NAME (node
), spc
, 0, false);
3326 /* Print the contents of the structure. */
3332 /* Print the fields of the structure. */
3335 tmp
= TYPE_FIELDS (node
);
3338 /* Avoid to print recursively the structure. */
3339 /* FIXME : Not implemented correctly...,
3340 what about the case when we have a cycle in the contain graph? ...
3341 Maybe this could be solved by looking at the scope in which the
3342 structure was declared. */
3343 if (TREE_TYPE (tmp
) != node
3344 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3345 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3347 print_declaration (pp
, tmp
, spc
+2, flags
);
3350 tmp
= DECL_CHAIN (tmp
);
3354 pp_right_brace (pp
);
3357 /* Return the priority of the operator CODE.
3359 From lowest to highest precedence with either left-to-right (L-R)
3360 or right-to-left (R-L) associativity]:
3363 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3375 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3376 15 [L-R] fn() [] -> .
3378 unary +, - and * have higher precedence than the corresponding binary
3382 op_code_prio (enum tree_code code
)
3399 case TRUTH_ORIF_EXPR
:
3402 case TRUTH_AND_EXPR
:
3403 case TRUTH_ANDIF_EXPR
:
3410 case TRUTH_XOR_EXPR
:
3427 case UNORDERED_EXPR
:
3438 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3439 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3440 case WIDEN_LSHIFT_EXPR
:
3443 case WIDEN_SUM_EXPR
:
3445 case POINTER_PLUS_EXPR
:
3449 case VEC_WIDEN_MULT_HI_EXPR
:
3450 case VEC_WIDEN_MULT_LO_EXPR
:
3451 case WIDEN_MULT_EXPR
:
3453 case WIDEN_MULT_PLUS_EXPR
:
3454 case WIDEN_MULT_MINUS_EXPR
:
3456 case MULT_HIGHPART_EXPR
:
3457 case TRUNC_DIV_EXPR
:
3459 case FLOOR_DIV_EXPR
:
3460 case ROUND_DIV_EXPR
:
3462 case EXACT_DIV_EXPR
:
3463 case TRUNC_MOD_EXPR
:
3465 case FLOOR_MOD_EXPR
:
3466 case ROUND_MOD_EXPR
:
3470 case TRUTH_NOT_EXPR
:
3472 case POSTINCREMENT_EXPR
:
3473 case POSTDECREMENT_EXPR
:
3474 case PREINCREMENT_EXPR
:
3475 case PREDECREMENT_EXPR
:
3481 case FIX_TRUNC_EXPR
:
3487 case ARRAY_RANGE_REF
:
3491 /* Special expressions. */
3497 case REDUC_MAX_EXPR
:
3498 case REDUC_MIN_EXPR
:
3499 case REDUC_PLUS_EXPR
:
3500 case VEC_UNPACK_HI_EXPR
:
3501 case VEC_UNPACK_LO_EXPR
:
3502 case VEC_UNPACK_FLOAT_HI_EXPR
:
3503 case VEC_UNPACK_FLOAT_LO_EXPR
:
3504 case VEC_PACK_TRUNC_EXPR
:
3505 case VEC_PACK_SAT_EXPR
:
3509 /* Return an arbitrarily high precedence to avoid surrounding single
3510 VAR_DECLs in ()s. */
3515 /* Return the priority of the operator OP. */
3518 op_prio (const_tree op
)
3520 enum tree_code code
;
3525 code
= TREE_CODE (op
);
3526 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3527 return op_prio (TREE_OPERAND (op
, 0));
3529 return op_code_prio (code
);
3532 /* Return the symbol associated with operator CODE. */
3535 op_symbol_code (enum tree_code code
)
3543 case TRUTH_ORIF_EXPR
:
3546 case TRUTH_AND_EXPR
:
3547 case TRUTH_ANDIF_EXPR
:
3553 case TRUTH_XOR_EXPR
:
3563 case UNORDERED_EXPR
:
3609 case WIDEN_LSHIFT_EXPR
:
3612 case POINTER_PLUS_EXPR
:
3618 case REDUC_PLUS_EXPR
:
3621 case WIDEN_SUM_EXPR
:
3624 case WIDEN_MULT_EXPR
:
3627 case MULT_HIGHPART_EXPR
:
3637 case TRUTH_NOT_EXPR
:
3644 case TRUNC_DIV_EXPR
:
3651 case FLOOR_DIV_EXPR
:
3654 case ROUND_DIV_EXPR
:
3657 case EXACT_DIV_EXPR
:
3660 case TRUNC_MOD_EXPR
:
3666 case FLOOR_MOD_EXPR
:
3669 case ROUND_MOD_EXPR
:
3672 case PREDECREMENT_EXPR
:
3675 case PREINCREMENT_EXPR
:
3678 case POSTDECREMENT_EXPR
:
3681 case POSTINCREMENT_EXPR
:
3691 return "<<< ??? >>>";
3695 /* Return the symbol associated with operator OP. */
3698 op_symbol (const_tree op
)
3700 return op_symbol_code (TREE_CODE (op
));
3703 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3704 the gimple_call_fn of a GIMPLE_CALL. */
3707 print_call_name (pretty_printer
*pp
, tree node
, int flags
)
3711 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3712 op0
= TREE_OPERAND (op0
, 0);
3715 switch (TREE_CODE (op0
))
3720 dump_function_name (pp
, op0
, flags
);
3726 op0
= TREE_OPERAND (op0
, 0);
3731 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3732 pp_string (pp
, ") ? ");
3733 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3734 pp_string (pp
, " : ");
3735 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3739 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3740 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
3742 dump_generic_node (pp
, op0
, 0, flags
, false);
3746 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3748 op0
= TREE_OPERAND (op0
, 0);
3755 dump_generic_node (pp
, op0
, 0, flags
, false);
3763 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3766 pretty_print_string (pretty_printer
*pp
, const char *str
)
3776 pp_string (pp
, "\\b");
3780 pp_string (pp
, "\\f");
3784 pp_string (pp
, "\\n");
3788 pp_string (pp
, "\\r");
3792 pp_string (pp
, "\\t");
3796 pp_string (pp
, "\\v");
3800 pp_string (pp
, "\\\\");
3804 pp_string (pp
, "\\\"");
3808 pp_string (pp
, "\\'");
3811 /* No need to handle \0; the loop terminates on \0. */
3814 pp_string (pp
, "\\1");
3818 pp_string (pp
, "\\2");
3822 pp_string (pp
, "\\3");
3826 pp_string (pp
, "\\4");
3830 pp_string (pp
, "\\5");
3834 pp_string (pp
, "\\6");
3838 pp_string (pp
, "\\7");
3842 pp_character (pp
, str
[0]);
3850 maybe_init_pretty_print (FILE *file
)
3854 tree_pp
= new pretty_printer ();
3855 pp_needs_newline (tree_pp
) = true;
3856 pp_translate_identifiers (tree_pp
) = false;
3859 tree_pp
->buffer
->stream
= file
;
3863 newline_and_indent (pretty_printer
*pp
, int spc
)
3869 /* Handle a %K format for TEXT. Separate from default_tree_printer so
3870 it can also be used in front ends.
3871 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3875 percent_K_format (text_info
*text
)
3877 tree t
= va_arg (*text
->args_ptr
, tree
), block
;
3878 text
->set_location (0, EXPR_LOCATION (t
), true);
3879 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3880 block
= TREE_BLOCK (t
);
3881 *pp_ti_abstract_origin (text
) = NULL
;
3885 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3886 representing the outermost block of an inlined function.
3887 So walk the BLOCK tree until we hit such a scope. */
3889 && TREE_CODE (block
) == BLOCK
)
3891 if (inlined_function_outer_scope_p (block
))
3893 *pp_ti_abstract_origin (text
) = block
;
3896 block
= BLOCK_SUPERCONTEXT (block
);
3902 && TREE_CODE (block
) == BLOCK
3903 && BLOCK_ABSTRACT_ORIGIN (block
))
3905 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3907 while (TREE_CODE (ao
) == BLOCK
3908 && BLOCK_ABSTRACT_ORIGIN (ao
)
3909 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3910 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3912 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3914 *pp_ti_abstract_origin (text
) = block
;
3917 block
= BLOCK_SUPERCONTEXT (block
);
3921 /* Print the identifier ID to PRETTY-PRINTER. */
3924 pp_tree_identifier (pretty_printer
*pp
, tree id
)
3926 if (pp_translate_identifiers (pp
))
3928 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
3929 pp_append_text (pp
, text
, text
+ strlen (text
));
3932 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
3933 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
3936 /* A helper function that is used to dump function information before the
3940 dump_function_header (FILE *dump_file
, tree fdecl
, int flags
)
3942 const char *dname
, *aname
;
3943 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
3944 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
3946 dname
= lang_hooks
.decl_printable_name (fdecl
, 2);
3948 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
3949 aname
= (IDENTIFIER_POINTER
3950 (DECL_ASSEMBLER_NAME (fdecl
)));
3952 aname
= "<unset-asm-name>";
3954 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
3955 dname
, aname
, fun
->funcdef_no
);
3956 if (!(flags
& TDF_NOUID
))
3957 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
3960 fprintf (dump_file
, ", cgraph_uid=%d", node
->uid
);
3961 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
3962 node
->frequency
== NODE_FREQUENCY_HOT
3964 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
3965 ? " (unlikely executed)"
3966 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
3967 ? " (executed once)"
3971 fprintf (dump_file
, ")\n\n");
3974 /* Dump double_int D to pretty_printer PP. UNS is true
3975 if D is unsigned and false otherwise. */
3977 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
3980 pp_wide_integer (pp
, d
.low
);
3981 else if (d
.fits_uhwi ())
3982 pp_unsigned_wide_integer (pp
, d
.low
);
3985 unsigned HOST_WIDE_INT low
= d
.low
;
3986 HOST_WIDE_INT high
= d
.high
;
3987 if (!uns
&& d
.is_negative ())
3990 high
= ~high
+ !low
;
3993 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
3995 sprintf (pp_buffer (pp
)->digit_buffer
,
3996 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
3997 (unsigned HOST_WIDE_INT
) high
, low
);
3998 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);