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);
1879 case BIT_INSERT_EXPR
:
1880 pp_string (pp
, "BIT_INSERT_EXPR <");
1881 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1882 pp_string (pp
, ", ");
1883 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1884 pp_string (pp
, ", ");
1885 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1886 pp_string (pp
, " (");
1887 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
1889 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
1891 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
1893 pp_string (pp
, " bits)>");
1897 case ARRAY_RANGE_REF
:
1898 op0
= TREE_OPERAND (node
, 0);
1899 if (op_prio (op0
) < op_prio (node
))
1901 dump_generic_node (pp
, op0
, spc
, flags
, false);
1902 if (op_prio (op0
) < op_prio (node
))
1903 pp_right_paren (pp
);
1904 pp_left_bracket (pp
);
1905 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1906 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1907 pp_string (pp
, " ...");
1908 pp_right_bracket (pp
);
1910 op0
= array_ref_low_bound (node
);
1911 op1
= array_ref_element_size (node
);
1913 if (!integer_zerop (op0
)
1914 || TREE_OPERAND (node
, 2)
1915 || TREE_OPERAND (node
, 3))
1917 pp_string (pp
, "{lb: ");
1918 dump_generic_node (pp
, op0
, spc
, flags
, false);
1919 pp_string (pp
, " sz: ");
1920 dump_generic_node (pp
, op1
, spc
, flags
, false);
1921 pp_right_brace (pp
);
1927 unsigned HOST_WIDE_INT ix
;
1929 bool is_struct_init
= false;
1930 bool is_array_init
= false;
1933 if (TREE_CLOBBER_P (node
))
1934 pp_string (pp
, "CLOBBER");
1935 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1936 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1937 is_struct_init
= true;
1938 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
1939 && TYPE_DOMAIN (TREE_TYPE (node
))
1940 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
1941 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
1944 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
1945 is_array_init
= true;
1946 curidx
= wi::to_widest (minv
);
1948 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1955 dump_generic_node (pp
, field
, spc
, flags
, false);
1958 else if (is_array_init
1959 && (TREE_CODE (field
) != INTEGER_CST
1960 || curidx
!= wi::to_widest (field
)))
1962 pp_left_bracket (pp
);
1963 if (TREE_CODE (field
) == RANGE_EXPR
)
1965 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
1967 pp_string (pp
, " ... ");
1968 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
1970 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
1971 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
1974 dump_generic_node (pp
, field
, spc
, flags
, false);
1975 if (TREE_CODE (field
) == INTEGER_CST
)
1976 curidx
= wi::to_widest (field
);
1977 pp_string (pp
, "]=");
1982 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1983 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1984 val
= TREE_OPERAND (val
, 0);
1985 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1986 dump_decl_name (pp
, val
, flags
);
1988 dump_generic_node (pp
, val
, spc
, flags
, false);
1989 if (ix
!= vec_safe_length (CONSTRUCTOR_ELTS (node
)) - 1)
1995 pp_right_brace (pp
);
2002 if (flags
& TDF_SLIM
)
2004 pp_string (pp
, "<COMPOUND_EXPR>");
2008 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2009 spc
, flags
, !(flags
& TDF_SLIM
));
2010 if (flags
& TDF_SLIM
)
2011 newline_and_indent (pp
, spc
);
2018 for (tp
= &TREE_OPERAND (node
, 1);
2019 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2020 tp
= &TREE_OPERAND (*tp
, 1))
2022 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2023 spc
, flags
, !(flags
& TDF_SLIM
));
2024 if (flags
& TDF_SLIM
)
2025 newline_and_indent (pp
, spc
);
2033 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2037 case STATEMENT_LIST
:
2039 tree_stmt_iterator si
;
2042 if (flags
& TDF_SLIM
)
2044 pp_string (pp
, "<STATEMENT_LIST>");
2048 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2051 newline_and_indent (pp
, spc
);
2054 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2061 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2066 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2071 pp_string (pp
, "TARGET_EXPR <");
2072 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2075 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2080 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2085 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2087 pp_string (pp
, "if (");
2088 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2089 pp_right_paren (pp
);
2090 /* The lowered cond_exprs should always be printed in full. */
2091 if (COND_EXPR_THEN (node
)
2092 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2093 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2094 && COND_EXPR_ELSE (node
)
2095 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2096 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2099 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2101 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2103 pp_string (pp
, " else ");
2104 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2108 else if (!(flags
& TDF_SLIM
))
2110 /* Output COND_EXPR_THEN. */
2111 if (COND_EXPR_THEN (node
))
2113 newline_and_indent (pp
, spc
+2);
2115 newline_and_indent (pp
, spc
+4);
2116 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2118 newline_and_indent (pp
, spc
+2);
2119 pp_right_brace (pp
);
2122 /* Output COND_EXPR_ELSE. */
2123 if (COND_EXPR_ELSE (node
)
2124 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2126 newline_and_indent (pp
, spc
);
2127 pp_string (pp
, "else");
2128 newline_and_indent (pp
, spc
+2);
2130 newline_and_indent (pp
, spc
+4);
2131 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2133 newline_and_indent (pp
, spc
+2);
2134 pp_right_brace (pp
);
2141 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2145 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2149 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2155 if (!(flags
& TDF_SLIM
))
2157 if (BIND_EXPR_VARS (node
))
2161 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2163 print_declaration (pp
, op0
, spc
+2, flags
);
2168 newline_and_indent (pp
, spc
+2);
2169 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2170 newline_and_indent (pp
, spc
);
2171 pp_right_brace (pp
);
2177 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2178 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2180 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2182 /* Print parameters. */
2187 call_expr_arg_iterator iter
;
2188 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2190 dump_generic_node (pp
, arg
, spc
, flags
, false);
2191 if (more_call_expr_args_p (&iter
))
2198 if (CALL_EXPR_VA_ARG_PACK (node
))
2200 if (call_expr_nargs (node
) > 0)
2205 pp_string (pp
, "__builtin_va_arg_pack ()");
2207 pp_right_paren (pp
);
2209 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2212 pp_string (pp
, " [static-chain: ");
2213 dump_generic_node (pp
, op1
, spc
, flags
, false);
2214 pp_right_bracket (pp
);
2217 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2218 pp_string (pp
, " [return slot optimization]");
2219 if (CALL_EXPR_TAILCALL (node
))
2220 pp_string (pp
, " [tail call]");
2223 case WITH_CLEANUP_EXPR
:
2227 case CLEANUP_POINT_EXPR
:
2228 pp_string (pp
, "<<cleanup_point ");
2229 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2230 pp_string (pp
, ">>");
2233 case PLACEHOLDER_EXPR
:
2234 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2235 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2239 /* Binary arithmetic and logic expressions. */
2240 case WIDEN_SUM_EXPR
:
2241 case WIDEN_MULT_EXPR
:
2243 case MULT_HIGHPART_EXPR
:
2245 case POINTER_PLUS_EXPR
:
2247 case TRUNC_DIV_EXPR
:
2249 case FLOOR_DIV_EXPR
:
2250 case ROUND_DIV_EXPR
:
2251 case TRUNC_MOD_EXPR
:
2253 case FLOOR_MOD_EXPR
:
2254 case ROUND_MOD_EXPR
:
2256 case EXACT_DIV_EXPR
:
2261 case WIDEN_LSHIFT_EXPR
:
2265 case TRUTH_ANDIF_EXPR
:
2266 case TRUTH_ORIF_EXPR
:
2267 case TRUTH_AND_EXPR
:
2269 case TRUTH_XOR_EXPR
:
2283 case UNORDERED_EXPR
:
2285 const char *op
= op_symbol (node
);
2286 op0
= TREE_OPERAND (node
, 0);
2287 op1
= TREE_OPERAND (node
, 1);
2289 /* When the operands are expressions with less priority,
2290 keep semantics of the tree representation. */
2291 if (op_prio (op0
) <= op_prio (node
))
2294 dump_generic_node (pp
, op0
, spc
, flags
, false);
2295 pp_right_paren (pp
);
2298 dump_generic_node (pp
, op0
, spc
, flags
, false);
2304 /* When the operands are expressions with less priority,
2305 keep semantics of the tree representation. */
2306 if (op_prio (op1
) <= op_prio (node
))
2309 dump_generic_node (pp
, op1
, spc
, flags
, false);
2310 pp_right_paren (pp
);
2313 dump_generic_node (pp
, op1
, spc
, flags
, false);
2317 /* Unary arithmetic and logic expressions. */
2320 case TRUTH_NOT_EXPR
:
2322 case PREDECREMENT_EXPR
:
2323 case PREINCREMENT_EXPR
:
2325 if (TREE_CODE (node
) == ADDR_EXPR
2326 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2327 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2328 ; /* Do not output '&' for strings and function pointers. */
2330 pp_string (pp
, op_symbol (node
));
2332 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2335 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2336 pp_right_paren (pp
);
2339 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2342 case POSTDECREMENT_EXPR
:
2343 case POSTINCREMENT_EXPR
:
2344 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2347 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2348 pp_right_paren (pp
);
2351 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2352 pp_string (pp
, op_symbol (node
));
2356 pp_string (pp
, "MIN_EXPR <");
2357 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2358 pp_string (pp
, ", ");
2359 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2364 pp_string (pp
, "MAX_EXPR <");
2365 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2366 pp_string (pp
, ", ");
2367 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2372 pp_string (pp
, "ABS_EXPR <");
2373 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2381 case ADDR_SPACE_CONVERT_EXPR
:
2382 case FIXED_CONVERT_EXPR
:
2383 case FIX_TRUNC_EXPR
:
2386 type
= TREE_TYPE (node
);
2387 op0
= TREE_OPERAND (node
, 0);
2388 if (type
!= TREE_TYPE (op0
))
2391 dump_generic_node (pp
, type
, spc
, flags
, false);
2392 pp_string (pp
, ") ");
2394 if (op_prio (op0
) < op_prio (node
))
2396 dump_generic_node (pp
, op0
, spc
, flags
, false);
2397 if (op_prio (op0
) < op_prio (node
))
2398 pp_right_paren (pp
);
2401 case VIEW_CONVERT_EXPR
:
2402 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2403 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2404 pp_string (pp
, ">(");
2405 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2406 pp_right_paren (pp
);
2410 pp_string (pp
, "((");
2411 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2412 pp_string (pp
, "))");
2415 case NON_LVALUE_EXPR
:
2416 pp_string (pp
, "NON_LVALUE_EXPR <");
2417 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2422 pp_string (pp
, "SAVE_EXPR <");
2423 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2428 pp_string (pp
, "COMPLEX_EXPR <");
2429 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2430 pp_string (pp
, ", ");
2431 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2436 pp_string (pp
, "CONJ_EXPR <");
2437 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2442 pp_string (pp
, "REALPART_EXPR <");
2443 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2448 pp_string (pp
, "IMAGPART_EXPR <");
2449 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2454 pp_string (pp
, "VA_ARG_EXPR <");
2455 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2459 case TRY_FINALLY_EXPR
:
2460 case TRY_CATCH_EXPR
:
2461 pp_string (pp
, "try");
2462 newline_and_indent (pp
, spc
+2);
2464 newline_and_indent (pp
, spc
+4);
2465 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2466 newline_and_indent (pp
, spc
+2);
2467 pp_right_brace (pp
);
2468 newline_and_indent (pp
, spc
);
2470 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2471 newline_and_indent (pp
, spc
+2);
2473 newline_and_indent (pp
, spc
+4);
2474 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2475 newline_and_indent (pp
, spc
+2);
2476 pp_right_brace (pp
);
2481 pp_string (pp
, "catch (");
2482 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2483 pp_right_paren (pp
);
2484 newline_and_indent (pp
, spc
+2);
2486 newline_and_indent (pp
, spc
+4);
2487 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2488 newline_and_indent (pp
, spc
+2);
2489 pp_right_brace (pp
);
2493 case EH_FILTER_EXPR
:
2494 pp_string (pp
, "<<<eh_filter (");
2495 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2496 pp_string (pp
, ")>>>");
2497 newline_and_indent (pp
, spc
+2);
2499 newline_and_indent (pp
, spc
+4);
2500 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2501 newline_and_indent (pp
, spc
+2);
2502 pp_right_brace (pp
);
2507 op0
= TREE_OPERAND (node
, 0);
2508 /* If this is for break or continue, don't bother printing it. */
2509 if (DECL_NAME (op0
))
2511 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2512 if (strcmp (name
, "break") == 0
2513 || strcmp (name
, "continue") == 0)
2516 dump_generic_node (pp
, op0
, spc
, flags
, false);
2518 if (DECL_NONLOCAL (op0
))
2519 pp_string (pp
, " [non-local]");
2523 pp_string (pp
, "while (1)");
2524 if (!(flags
& TDF_SLIM
))
2526 newline_and_indent (pp
, spc
+2);
2528 newline_and_indent (pp
, spc
+4);
2529 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2530 newline_and_indent (pp
, spc
+2);
2531 pp_right_brace (pp
);
2537 pp_string (pp
, "// predicted ");
2538 if (PREDICT_EXPR_OUTCOME (node
))
2539 pp_string (pp
, "likely by ");
2541 pp_string (pp
, "unlikely by ");
2542 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2543 pp_string (pp
, " predictor.");
2547 pp_string (pp
, "ANNOTATE_EXPR <");
2548 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2549 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2551 case annot_expr_ivdep_kind
:
2552 pp_string (pp
, ", ivdep");
2554 case annot_expr_no_vector_kind
:
2555 pp_string (pp
, ", no-vector");
2557 case annot_expr_vector_kind
:
2558 pp_string (pp
, ", vector");
2567 pp_string (pp
, "return");
2568 op0
= TREE_OPERAND (node
, 0);
2572 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2573 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2576 dump_generic_node (pp
, op0
, spc
, flags
, false);
2581 pp_string (pp
, "if (");
2582 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2583 pp_string (pp
, ") break");
2587 pp_string (pp
, "switch (");
2588 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2589 pp_right_paren (pp
);
2590 if (!(flags
& TDF_SLIM
))
2592 newline_and_indent (pp
, spc
+2);
2594 if (SWITCH_BODY (node
))
2596 newline_and_indent (pp
, spc
+4);
2597 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2602 tree vec
= SWITCH_LABELS (node
);
2603 size_t i
, n
= TREE_VEC_LENGTH (vec
);
2604 for (i
= 0; i
< n
; ++i
)
2606 tree elt
= TREE_VEC_ELT (vec
, i
);
2607 newline_and_indent (pp
, spc
+4);
2610 dump_generic_node (pp
, elt
, spc
+4, flags
, false);
2611 pp_string (pp
, " goto ");
2612 dump_generic_node (pp
, CASE_LABEL (elt
), spc
+4,
2617 pp_string (pp
, "case ???: goto ???;");
2620 newline_and_indent (pp
, spc
+2);
2621 pp_right_brace (pp
);
2627 op0
= GOTO_DESTINATION (node
);
2628 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2630 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2631 if (strcmp (name
, "break") == 0
2632 || strcmp (name
, "continue") == 0)
2634 pp_string (pp
, name
);
2638 pp_string (pp
, "goto ");
2639 dump_generic_node (pp
, op0
, spc
, flags
, false);
2643 pp_string (pp
, "__asm__");
2644 if (ASM_VOLATILE_P (node
))
2645 pp_string (pp
, " __volatile__");
2647 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2649 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2651 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2652 if (ASM_CLOBBERS (node
))
2655 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2657 pp_right_paren (pp
);
2660 case CASE_LABEL_EXPR
:
2661 if (CASE_LOW (node
) && CASE_HIGH (node
))
2663 pp_string (pp
, "case ");
2664 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2665 pp_string (pp
, " ... ");
2666 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2668 else if (CASE_LOW (node
))
2670 pp_string (pp
, "case ");
2671 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2674 pp_string (pp
, "default");
2679 pp_string (pp
, "OBJ_TYPE_REF(");
2680 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2682 if (!(flags
& TDF_SLIM
) && virtual_method_call_p (node
))
2684 pp_string (pp
, "(");
2685 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2686 pp_string (pp
, ")");
2688 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2690 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2691 pp_right_paren (pp
);
2695 if (SSA_NAME_IDENTIFIER (node
))
2697 if ((flags
& TDF_NOUID
)
2698 && SSA_NAME_VAR (node
)
2699 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
2700 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
2702 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2706 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2707 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2708 pp_string (pp
, "(D)");
2709 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2710 pp_string (pp
, "(ab)");
2713 case WITH_SIZE_EXPR
:
2714 pp_string (pp
, "WITH_SIZE_EXPR <");
2715 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2716 pp_string (pp
, ", ");
2717 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2722 pp_string (pp
, "ASSERT_EXPR <");
2723 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2724 pp_string (pp
, ", ");
2725 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2730 pp_string (pp
, "scev_known");
2733 case SCEV_NOT_KNOWN
:
2734 pp_string (pp
, "scev_not_known");
2737 case POLYNOMIAL_CHREC
:
2739 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2740 pp_string (pp
, ", +, ");
2741 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2742 pp_string (pp
, "}_");
2743 dump_generic_node (pp
, CHREC_VAR (node
), spc
, flags
, false);
2747 case REALIGN_LOAD_EXPR
:
2748 pp_string (pp
, "REALIGN_LOAD <");
2749 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2750 pp_string (pp
, ", ");
2751 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2752 pp_string (pp
, ", ");
2753 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2758 pp_string (pp
, " VEC_COND_EXPR < ");
2759 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2760 pp_string (pp
, " , ");
2761 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2762 pp_string (pp
, " , ");
2763 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2764 pp_string (pp
, " > ");
2768 pp_string (pp
, " VEC_PERM_EXPR < ");
2769 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2770 pp_string (pp
, " , ");
2771 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2772 pp_string (pp
, " , ");
2773 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2774 pp_string (pp
, " > ");
2778 pp_string (pp
, " DOT_PROD_EXPR < ");
2779 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2780 pp_string (pp
, ", ");
2781 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2782 pp_string (pp
, ", ");
2783 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2784 pp_string (pp
, " > ");
2787 case WIDEN_MULT_PLUS_EXPR
:
2788 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
2789 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2790 pp_string (pp
, ", ");
2791 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2792 pp_string (pp
, ", ");
2793 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2794 pp_string (pp
, " > ");
2797 case WIDEN_MULT_MINUS_EXPR
:
2798 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
2799 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2800 pp_string (pp
, ", ");
2801 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2802 pp_string (pp
, ", ");
2803 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2804 pp_string (pp
, " > ");
2808 pp_string (pp
, " FMA_EXPR < ");
2809 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2810 pp_string (pp
, ", ");
2811 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2812 pp_string (pp
, ", ");
2813 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2814 pp_string (pp
, " > ");
2818 pp_string (pp
, "#pragma acc parallel");
2819 goto dump_omp_clauses_body
;
2822 pp_string (pp
, "#pragma acc kernels");
2823 goto dump_omp_clauses_body
;
2826 pp_string (pp
, "#pragma acc data");
2827 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2830 case OACC_HOST_DATA
:
2831 pp_string (pp
, "#pragma acc host_data");
2832 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2836 pp_string (pp
, "#pragma acc declare");
2837 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2841 pp_string (pp
, "#pragma acc update");
2842 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2845 case OACC_ENTER_DATA
:
2846 pp_string (pp
, "#pragma acc enter data");
2847 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2850 case OACC_EXIT_DATA
:
2851 pp_string (pp
, "#pragma acc exit data");
2852 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2856 pp_string (pp
, "#pragma acc cache");
2857 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2861 pp_string (pp
, "#pragma omp parallel");
2862 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2865 dump_omp_clauses_body
:
2866 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2870 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2872 newline_and_indent (pp
, spc
+ 2);
2874 newline_and_indent (pp
, spc
+ 4);
2875 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2876 newline_and_indent (pp
, spc
+ 2);
2877 pp_right_brace (pp
);
2883 pp_string (pp
, "#pragma omp task");
2884 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2888 pp_string (pp
, "#pragma omp for");
2892 pp_string (pp
, "#pragma omp simd");
2896 pp_string (pp
, "#pragma simd");
2900 /* This label points one line after dumping the clauses.
2901 For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2902 parameters are printed out. */
2903 goto dump_omp_loop_cilk_for
;
2905 case OMP_DISTRIBUTE
:
2906 pp_string (pp
, "#pragma omp distribute");
2910 pp_string (pp
, "#pragma omp taskloop");
2914 pp_string (pp
, "#pragma acc loop");
2918 pp_string (pp
, "#pragma omp teams");
2919 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
2922 case OMP_TARGET_DATA
:
2923 pp_string (pp
, "#pragma omp target data");
2924 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
2927 case OMP_TARGET_ENTER_DATA
:
2928 pp_string (pp
, "#pragma omp target enter data");
2929 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2933 case OMP_TARGET_EXIT_DATA
:
2934 pp_string (pp
, "#pragma omp target exit data");
2935 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2940 pp_string (pp
, "#pragma omp target");
2941 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
2944 case OMP_TARGET_UPDATE
:
2945 pp_string (pp
, "#pragma omp target update");
2946 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
2951 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2953 dump_omp_loop_cilk_for
:
2954 if (!(flags
& TDF_SLIM
))
2958 if (OMP_FOR_PRE_BODY (node
))
2960 if (TREE_CODE (node
) == CILK_FOR
)
2961 pp_string (pp
, " ");
2963 newline_and_indent (pp
, spc
+ 2);
2966 newline_and_indent (pp
, spc
);
2967 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
2970 if (OMP_FOR_INIT (node
))
2973 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
2976 if (TREE_CODE (node
) != CILK_FOR
|| OMP_FOR_PRE_BODY (node
))
2977 newline_and_indent (pp
, spc
);
2978 if (TREE_CODE (node
) == CILK_FOR
)
2979 pp_string (pp
, "_Cilk_for (");
2981 pp_string (pp
, "for (");
2982 dump_generic_node (pp
,
2983 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
2985 pp_string (pp
, "; ");
2986 dump_generic_node (pp
,
2987 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
2989 pp_string (pp
, "; ");
2990 dump_generic_node (pp
,
2991 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
2993 pp_right_paren (pp
);
2995 if (TREE_CODE (node
) == CILK_FOR
)
2996 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2998 if (OMP_FOR_BODY (node
))
3000 newline_and_indent (pp
, spc
+ 2);
3002 newline_and_indent (pp
, spc
+ 4);
3003 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3005 newline_and_indent (pp
, spc
+ 2);
3006 pp_right_brace (pp
);
3008 if (OMP_FOR_INIT (node
))
3009 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3010 if (OMP_FOR_PRE_BODY (node
))
3013 newline_and_indent (pp
, spc
+ 2);
3014 pp_right_brace (pp
);
3021 pp_string (pp
, "#pragma omp sections");
3022 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3026 pp_string (pp
, "#pragma omp section");
3030 pp_string (pp
, "#pragma omp master");
3034 pp_string (pp
, "#pragma omp taskgroup");
3038 pp_string (pp
, "#pragma omp ordered");
3039 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3043 pp_string (pp
, "#pragma omp critical");
3044 if (OMP_CRITICAL_NAME (node
))
3048 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3050 pp_right_paren (pp
);
3052 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3056 pp_string (pp
, "#pragma omp atomic");
3057 if (OMP_ATOMIC_SEQ_CST (node
))
3058 pp_string (pp
, " seq_cst");
3059 newline_and_indent (pp
, spc
+ 2);
3060 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3064 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3067 case OMP_ATOMIC_READ
:
3068 pp_string (pp
, "#pragma omp atomic read");
3069 if (OMP_ATOMIC_SEQ_CST (node
))
3070 pp_string (pp
, " seq_cst");
3071 newline_and_indent (pp
, spc
+ 2);
3072 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3076 case OMP_ATOMIC_CAPTURE_OLD
:
3077 case OMP_ATOMIC_CAPTURE_NEW
:
3078 pp_string (pp
, "#pragma omp atomic capture");
3079 if (OMP_ATOMIC_SEQ_CST (node
))
3080 pp_string (pp
, " seq_cst");
3081 newline_and_indent (pp
, spc
+ 2);
3082 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3086 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3090 pp_string (pp
, "#pragma omp single");
3091 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3095 dump_omp_clause (pp
, node
, spc
, flags
);
3099 case TRANSACTION_EXPR
:
3100 if (TRANSACTION_EXPR_OUTER (node
))
3101 pp_string (pp
, "__transaction_atomic [[outer]]");
3102 else if (TRANSACTION_EXPR_RELAXED (node
))
3103 pp_string (pp
, "__transaction_relaxed");
3105 pp_string (pp
, "__transaction_atomic");
3106 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3108 newline_and_indent (pp
, spc
);
3110 newline_and_indent (pp
, spc
+ 2);
3111 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3112 spc
+ 2, flags
, false);
3113 newline_and_indent (pp
, spc
);
3114 pp_right_brace (pp
);
3119 case REDUC_MAX_EXPR
:
3120 pp_string (pp
, " REDUC_MAX_EXPR < ");
3121 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3122 pp_string (pp
, " > ");
3125 case REDUC_MIN_EXPR
:
3126 pp_string (pp
, " REDUC_MIN_EXPR < ");
3127 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3128 pp_string (pp
, " > ");
3131 case REDUC_PLUS_EXPR
:
3132 pp_string (pp
, " REDUC_PLUS_EXPR < ");
3133 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3134 pp_string (pp
, " > ");
3137 case VEC_WIDEN_MULT_HI_EXPR
:
3138 case VEC_WIDEN_MULT_LO_EXPR
:
3139 case VEC_WIDEN_MULT_EVEN_EXPR
:
3140 case VEC_WIDEN_MULT_ODD_EXPR
:
3141 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3142 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3144 for (str
= get_tree_code_name (code
); *str
; str
++)
3145 pp_character (pp
, TOUPPER (*str
));
3146 pp_string (pp
, " < ");
3147 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3148 pp_string (pp
, ", ");
3149 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3150 pp_string (pp
, " > ");
3153 case VEC_UNPACK_HI_EXPR
:
3154 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3155 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3156 pp_string (pp
, " > ");
3159 case VEC_UNPACK_LO_EXPR
:
3160 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3161 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3162 pp_string (pp
, " > ");
3165 case VEC_UNPACK_FLOAT_HI_EXPR
:
3166 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3167 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3168 pp_string (pp
, " > ");
3171 case VEC_UNPACK_FLOAT_LO_EXPR
:
3172 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3173 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3174 pp_string (pp
, " > ");
3177 case VEC_PACK_TRUNC_EXPR
:
3178 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3179 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3180 pp_string (pp
, ", ");
3181 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3182 pp_string (pp
, " > ");
3185 case VEC_PACK_SAT_EXPR
:
3186 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3187 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3188 pp_string (pp
, ", ");
3189 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3190 pp_string (pp
, " > ");
3193 case VEC_PACK_FIX_TRUNC_EXPR
:
3194 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3195 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3196 pp_string (pp
, ", ");
3197 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3198 pp_string (pp
, " > ");
3202 dump_block_node (pp
, node
, spc
, flags
);
3205 case CILK_SPAWN_STMT
:
3206 pp_string (pp
, "_Cilk_spawn ");
3207 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3210 case CILK_SYNC_STMT
:
3211 pp_string (pp
, "_Cilk_sync");
3218 if (is_stmt
&& is_expr
)
3224 /* Print the declaration of a variable. */
3227 print_declaration (pretty_printer
*pp
, tree t
, int spc
, int flags
)
3231 if (TREE_CODE(t
) == NAMELIST_DECL
)
3233 pp_string(pp
, "namelist ");
3234 dump_decl_name (pp
, t
, flags
);
3239 if (TREE_CODE (t
) == TYPE_DECL
)
3240 pp_string (pp
, "typedef ");
3242 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3243 pp_string (pp
, "register ");
3245 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3246 pp_string (pp
, "extern ");
3247 else if (TREE_STATIC (t
))
3248 pp_string (pp
, "static ");
3250 /* Print the type and name. */
3251 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3255 /* Print array's type. */
3256 tmp
= TREE_TYPE (t
);
3257 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3258 tmp
= TREE_TYPE (tmp
);
3259 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3261 /* Print variable's name. */
3263 dump_generic_node (pp
, t
, spc
, flags
, false);
3265 /* Print the dimensions. */
3266 tmp
= TREE_TYPE (t
);
3267 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3269 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3270 tmp
= TREE_TYPE (tmp
);
3273 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3275 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3277 dump_decl_name (pp
, t
, flags
);
3278 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3282 /* Print type declaration. */
3283 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3285 /* Print variable's name. */
3287 dump_generic_node (pp
, t
, spc
, flags
, false);
3290 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
3292 pp_string (pp
, " __asm__ ");
3294 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3295 pp_right_paren (pp
);
3298 /* The initial value of a function serves to determine whether the function
3299 is declared or defined. So the following does not apply to function
3301 if (TREE_CODE (t
) != FUNCTION_DECL
)
3303 /* Print the initial value. */
3304 if (DECL_INITIAL (t
))
3309 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3313 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
3315 pp_string (pp
, " [value-expr: ");
3316 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3317 pp_right_bracket (pp
);
3324 /* Prints a structure: name, fields, and methods.
3325 FIXME: Still incomplete. */
3328 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
, int flags
)
3330 /* Print the name of the structure. */
3331 if (TYPE_NAME (node
))
3334 if (TREE_CODE (node
) == RECORD_TYPE
)
3335 pp_string (pp
, "struct ");
3336 else if ((TREE_CODE (node
) == UNION_TYPE
3337 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3338 pp_string (pp
, "union ");
3340 dump_generic_node (pp
, TYPE_NAME (node
), spc
, 0, false);
3343 /* Print the contents of the structure. */
3349 /* Print the fields of the structure. */
3352 tmp
= TYPE_FIELDS (node
);
3355 /* Avoid to print recursively the structure. */
3356 /* FIXME : Not implemented correctly...,
3357 what about the case when we have a cycle in the contain graph? ...
3358 Maybe this could be solved by looking at the scope in which the
3359 structure was declared. */
3360 if (TREE_TYPE (tmp
) != node
3361 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3362 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3364 print_declaration (pp
, tmp
, spc
+2, flags
);
3367 tmp
= DECL_CHAIN (tmp
);
3371 pp_right_brace (pp
);
3374 /* Return the priority of the operator CODE.
3376 From lowest to highest precedence with either left-to-right (L-R)
3377 or right-to-left (R-L) associativity]:
3380 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3392 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3393 15 [L-R] fn() [] -> .
3395 unary +, - and * have higher precedence than the corresponding binary
3399 op_code_prio (enum tree_code code
)
3416 case TRUTH_ORIF_EXPR
:
3419 case TRUTH_AND_EXPR
:
3420 case TRUTH_ANDIF_EXPR
:
3427 case TRUTH_XOR_EXPR
:
3444 case UNORDERED_EXPR
:
3455 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3456 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3457 case WIDEN_LSHIFT_EXPR
:
3460 case WIDEN_SUM_EXPR
:
3462 case POINTER_PLUS_EXPR
:
3466 case VEC_WIDEN_MULT_HI_EXPR
:
3467 case VEC_WIDEN_MULT_LO_EXPR
:
3468 case WIDEN_MULT_EXPR
:
3470 case WIDEN_MULT_PLUS_EXPR
:
3471 case WIDEN_MULT_MINUS_EXPR
:
3473 case MULT_HIGHPART_EXPR
:
3474 case TRUNC_DIV_EXPR
:
3476 case FLOOR_DIV_EXPR
:
3477 case ROUND_DIV_EXPR
:
3479 case EXACT_DIV_EXPR
:
3480 case TRUNC_MOD_EXPR
:
3482 case FLOOR_MOD_EXPR
:
3483 case ROUND_MOD_EXPR
:
3487 case TRUTH_NOT_EXPR
:
3489 case POSTINCREMENT_EXPR
:
3490 case POSTDECREMENT_EXPR
:
3491 case PREINCREMENT_EXPR
:
3492 case PREDECREMENT_EXPR
:
3498 case FIX_TRUNC_EXPR
:
3504 case ARRAY_RANGE_REF
:
3508 /* Special expressions. */
3514 case REDUC_MAX_EXPR
:
3515 case REDUC_MIN_EXPR
:
3516 case REDUC_PLUS_EXPR
:
3517 case VEC_UNPACK_HI_EXPR
:
3518 case VEC_UNPACK_LO_EXPR
:
3519 case VEC_UNPACK_FLOAT_HI_EXPR
:
3520 case VEC_UNPACK_FLOAT_LO_EXPR
:
3521 case VEC_PACK_TRUNC_EXPR
:
3522 case VEC_PACK_SAT_EXPR
:
3526 /* Return an arbitrarily high precedence to avoid surrounding single
3527 VAR_DECLs in ()s. */
3532 /* Return the priority of the operator OP. */
3535 op_prio (const_tree op
)
3537 enum tree_code code
;
3542 code
= TREE_CODE (op
);
3543 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3544 return op_prio (TREE_OPERAND (op
, 0));
3546 return op_code_prio (code
);
3549 /* Return the symbol associated with operator CODE. */
3552 op_symbol_code (enum tree_code code
)
3560 case TRUTH_ORIF_EXPR
:
3563 case TRUTH_AND_EXPR
:
3564 case TRUTH_ANDIF_EXPR
:
3570 case TRUTH_XOR_EXPR
:
3580 case UNORDERED_EXPR
:
3626 case WIDEN_LSHIFT_EXPR
:
3629 case POINTER_PLUS_EXPR
:
3635 case REDUC_PLUS_EXPR
:
3638 case WIDEN_SUM_EXPR
:
3641 case WIDEN_MULT_EXPR
:
3644 case MULT_HIGHPART_EXPR
:
3654 case TRUTH_NOT_EXPR
:
3661 case TRUNC_DIV_EXPR
:
3668 case FLOOR_DIV_EXPR
:
3671 case ROUND_DIV_EXPR
:
3674 case EXACT_DIV_EXPR
:
3677 case TRUNC_MOD_EXPR
:
3683 case FLOOR_MOD_EXPR
:
3686 case ROUND_MOD_EXPR
:
3689 case PREDECREMENT_EXPR
:
3692 case PREINCREMENT_EXPR
:
3695 case POSTDECREMENT_EXPR
:
3698 case POSTINCREMENT_EXPR
:
3708 return "<<< ??? >>>";
3712 /* Return the symbol associated with operator OP. */
3715 op_symbol (const_tree op
)
3717 return op_symbol_code (TREE_CODE (op
));
3720 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3721 the gimple_call_fn of a GIMPLE_CALL. */
3724 print_call_name (pretty_printer
*pp
, tree node
, int flags
)
3728 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3729 op0
= TREE_OPERAND (op0
, 0);
3732 switch (TREE_CODE (op0
))
3737 dump_function_name (pp
, op0
, flags
);
3743 op0
= TREE_OPERAND (op0
, 0);
3748 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3749 pp_string (pp
, ") ? ");
3750 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3751 pp_string (pp
, " : ");
3752 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3756 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3757 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
3759 dump_generic_node (pp
, op0
, 0, flags
, false);
3763 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3765 op0
= TREE_OPERAND (op0
, 0);
3772 dump_generic_node (pp
, op0
, 0, flags
, false);
3780 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3783 pretty_print_string (pretty_printer
*pp
, const char *str
)
3793 pp_string (pp
, "\\b");
3797 pp_string (pp
, "\\f");
3801 pp_string (pp
, "\\n");
3805 pp_string (pp
, "\\r");
3809 pp_string (pp
, "\\t");
3813 pp_string (pp
, "\\v");
3817 pp_string (pp
, "\\\\");
3821 pp_string (pp
, "\\\"");
3825 pp_string (pp
, "\\'");
3828 /* No need to handle \0; the loop terminates on \0. */
3831 pp_string (pp
, "\\1");
3835 pp_string (pp
, "\\2");
3839 pp_string (pp
, "\\3");
3843 pp_string (pp
, "\\4");
3847 pp_string (pp
, "\\5");
3851 pp_string (pp
, "\\6");
3855 pp_string (pp
, "\\7");
3859 pp_character (pp
, str
[0]);
3867 maybe_init_pretty_print (FILE *file
)
3871 tree_pp
= new pretty_printer ();
3872 pp_needs_newline (tree_pp
) = true;
3873 pp_translate_identifiers (tree_pp
) = false;
3876 tree_pp
->buffer
->stream
= file
;
3880 newline_and_indent (pretty_printer
*pp
, int spc
)
3886 /* Handle a %K format for TEXT. Separate from default_tree_printer so
3887 it can also be used in front ends.
3888 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3892 percent_K_format (text_info
*text
)
3894 tree t
= va_arg (*text
->args_ptr
, tree
), block
;
3895 text
->set_location (0, EXPR_LOCATION (t
), true);
3896 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3897 block
= TREE_BLOCK (t
);
3898 *pp_ti_abstract_origin (text
) = NULL
;
3902 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3903 representing the outermost block of an inlined function.
3904 So walk the BLOCK tree until we hit such a scope. */
3906 && TREE_CODE (block
) == BLOCK
)
3908 if (inlined_function_outer_scope_p (block
))
3910 *pp_ti_abstract_origin (text
) = block
;
3913 block
= BLOCK_SUPERCONTEXT (block
);
3919 && TREE_CODE (block
) == BLOCK
3920 && BLOCK_ABSTRACT_ORIGIN (block
))
3922 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3924 while (TREE_CODE (ao
) == BLOCK
3925 && BLOCK_ABSTRACT_ORIGIN (ao
)
3926 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3927 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3929 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3931 *pp_ti_abstract_origin (text
) = block
;
3934 block
= BLOCK_SUPERCONTEXT (block
);
3938 /* Print the identifier ID to PRETTY-PRINTER. */
3941 pp_tree_identifier (pretty_printer
*pp
, tree id
)
3943 if (pp_translate_identifiers (pp
))
3945 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
3946 pp_append_text (pp
, text
, text
+ strlen (text
));
3949 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
3950 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
3953 /* A helper function that is used to dump function information before the
3957 dump_function_header (FILE *dump_file
, tree fdecl
, int flags
)
3959 const char *dname
, *aname
;
3960 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
3961 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
3963 dname
= lang_hooks
.decl_printable_name (fdecl
, 2);
3965 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
3966 aname
= (IDENTIFIER_POINTER
3967 (DECL_ASSEMBLER_NAME (fdecl
)));
3969 aname
= "<unset-asm-name>";
3971 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
3972 dname
, aname
, fun
->funcdef_no
);
3973 if (!(flags
& TDF_NOUID
))
3974 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
3977 fprintf (dump_file
, ", cgraph_uid=%d", node
->uid
);
3978 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
3979 node
->frequency
== NODE_FREQUENCY_HOT
3981 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
3982 ? " (unlikely executed)"
3983 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
3984 ? " (executed once)"
3988 fprintf (dump_file
, ")\n\n");
3991 /* Dump double_int D to pretty_printer PP. UNS is true
3992 if D is unsigned and false otherwise. */
3994 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
3997 pp_wide_integer (pp
, d
.low
);
3998 else if (d
.fits_uhwi ())
3999 pp_unsigned_wide_integer (pp
, d
.low
);
4002 unsigned HOST_WIDE_INT low
= d
.low
;
4003 HOST_WIDE_INT high
= d
.high
;
4004 if (!uns
&& d
.is_negative ())
4007 high
= ~high
+ !low
;
4010 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4012 sprintf (pp_buffer (pp
)->digit_buffer
,
4013 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4014 (unsigned HOST_WIDE_INT
) high
, low
);
4015 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);