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 char uid_sep
= (flags
& TDF_GIMPLE
) ? '_' : '.';
261 if ((flags
& TDF_UID
) || DECL_NAME (node
) == NULL_TREE
)
263 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
264 pp_printf (pp
, "L%c%d", uid_sep
, (int) LABEL_DECL_UID (node
));
265 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
267 if (flags
& TDF_NOUID
)
268 pp_string (pp
, "D#xxxx");
270 pp_printf (pp
, "D#%i", DEBUG_TEMP_UID (node
));
274 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
275 if (flags
& TDF_NOUID
)
276 pp_printf (pp
, "%c.xxxx", c
);
278 pp_printf (pp
, "%c%c%u", c
, uid_sep
, DECL_UID (node
));
281 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
283 if (flags
& TDF_NOUID
)
284 pp_printf (pp
, "ptD.xxxx");
286 pp_printf (pp
, "ptD.%u", DECL_PT_UID (node
));
290 /* Like the above, but used for pretty printing function calls. */
293 dump_function_name (pretty_printer
*pp
, tree node
, int flags
)
295 if (CONVERT_EXPR_P (node
))
296 node
= TREE_OPERAND (node
, 0);
297 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
298 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
300 dump_decl_name (pp
, node
, flags
);
303 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
304 FLAGS are as in dump_generic_node. */
307 dump_function_declaration (pretty_printer
*pp
, tree node
,
310 bool wrote_arg
= false;
316 /* Print the argument types. */
317 arg
= TYPE_ARG_TYPES (node
);
318 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
326 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
327 arg
= TREE_CHAIN (arg
);
330 /* Drop the trailing void_type_node if we had any previous argument. */
331 if (arg
== void_list_node
&& !wrote_arg
)
332 pp_string (pp
, "void");
333 /* Properly dump vararg function types. */
334 else if (!arg
&& wrote_arg
)
335 pp_string (pp
, ", ...");
336 /* Avoid printing any arg for unprototyped functions. */
341 /* Dump the domain associated with an array. */
344 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, int flags
)
346 pp_left_bracket (pp
);
349 tree min
= TYPE_MIN_VALUE (domain
);
350 tree max
= TYPE_MAX_VALUE (domain
);
353 && integer_zerop (min
)
354 && tree_fits_shwi_p (max
))
355 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
359 dump_generic_node (pp
, min
, spc
, flags
, false);
362 dump_generic_node (pp
, max
, spc
, flags
, false);
366 pp_string (pp
, "<unknown>");
367 pp_right_bracket (pp
);
371 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
372 dump_generic_node. */
375 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, int flags
)
379 switch (OMP_CLAUSE_CODE (clause
))
381 case OMP_CLAUSE_PRIVATE
:
384 case OMP_CLAUSE_SHARED
:
387 case OMP_CLAUSE_FIRSTPRIVATE
:
388 name
= "firstprivate";
390 case OMP_CLAUSE_LASTPRIVATE
:
391 name
= "lastprivate";
393 case OMP_CLAUSE_COPYIN
:
396 case OMP_CLAUSE_COPYPRIVATE
:
397 name
= "copyprivate";
399 case OMP_CLAUSE_UNIFORM
:
402 case OMP_CLAUSE_USE_DEVICE_PTR
:
403 name
= "use_device_ptr";
405 case OMP_CLAUSE_IS_DEVICE_PTR
:
406 name
= "is_device_ptr";
408 case OMP_CLAUSE__LOOPTEMP_
:
411 case OMP_CLAUSE_TO_DECLARE
:
414 case OMP_CLAUSE_LINK
:
418 pp_string (pp
, name
);
420 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
425 case OMP_CLAUSE_REDUCTION
:
426 pp_string (pp
, "reduction(");
427 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
430 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
433 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
439 pp_string (pp
, "if(");
440 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
442 case ERROR_MARK
: break;
443 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
444 case OMP_TASK
: pp_string (pp
, "task:"); break;
445 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
446 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
447 case OMP_TARGET
: pp_string (pp
, "target:"); break;
448 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
449 case OMP_TARGET_ENTER_DATA
:
450 pp_string (pp
, "target enter data:"); break;
451 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
452 default: gcc_unreachable ();
454 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
459 case OMP_CLAUSE_NUM_THREADS
:
460 pp_string (pp
, "num_threads(");
461 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
466 case OMP_CLAUSE__CILK_FOR_COUNT_
:
467 pp_string (pp
, "_Cilk_for_count_(");
468 dump_generic_node (pp
, OMP_CLAUSE_OPERAND (clause
, 0),
473 case OMP_CLAUSE_NOWAIT
:
474 pp_string (pp
, "nowait");
476 case OMP_CLAUSE_ORDERED
:
477 pp_string (pp
, "ordered");
478 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
481 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
487 case OMP_CLAUSE_DEFAULT
:
488 pp_string (pp
, "default(");
489 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
491 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
493 case OMP_CLAUSE_DEFAULT_SHARED
:
494 pp_string (pp
, "shared");
496 case OMP_CLAUSE_DEFAULT_NONE
:
497 pp_string (pp
, "none");
499 case OMP_CLAUSE_DEFAULT_PRIVATE
:
500 pp_string (pp
, "private");
502 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
503 pp_string (pp
, "firstprivate");
511 case OMP_CLAUSE_SCHEDULE
:
512 pp_string (pp
, "schedule(");
513 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
514 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
515 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
517 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
518 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
519 pp_string (pp
, "monotonic");
521 pp_string (pp
, "nonmonotonic");
522 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
527 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
528 pp_string (pp
, "simd:");
530 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
532 case OMP_CLAUSE_SCHEDULE_STATIC
:
533 pp_string (pp
, "static");
535 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
536 pp_string (pp
, "dynamic");
538 case OMP_CLAUSE_SCHEDULE_GUIDED
:
539 pp_string (pp
, "guided");
541 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
542 pp_string (pp
, "runtime");
544 case OMP_CLAUSE_SCHEDULE_AUTO
:
545 pp_string (pp
, "auto");
547 case OMP_CLAUSE_SCHEDULE_CILKFOR
:
548 pp_string (pp
, "cilk-for grain");
553 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
556 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
562 case OMP_CLAUSE_UNTIED
:
563 pp_string (pp
, "untied");
566 case OMP_CLAUSE_COLLAPSE
:
567 pp_string (pp
, "collapse(");
568 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
573 case OMP_CLAUSE_FINAL
:
574 pp_string (pp
, "final(");
575 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
580 case OMP_CLAUSE_MERGEABLE
:
581 pp_string (pp
, "mergeable");
584 case OMP_CLAUSE_LINEAR
:
585 pp_string (pp
, "linear(");
586 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
588 case OMP_CLAUSE_LINEAR_DEFAULT
:
590 case OMP_CLAUSE_LINEAR_REF
:
591 pp_string (pp
, "ref(");
593 case OMP_CLAUSE_LINEAR_VAL
:
594 pp_string (pp
, "val(");
596 case OMP_CLAUSE_LINEAR_UVAL
:
597 pp_string (pp
, "uval(");
602 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
604 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
607 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
612 case OMP_CLAUSE_ALIGNED
:
613 pp_string (pp
, "aligned(");
614 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
616 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
619 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
625 case OMP_CLAUSE_DEPEND
:
626 pp_string (pp
, "depend(");
627 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
629 case OMP_CLAUSE_DEPEND_IN
:
630 pp_string (pp
, "in");
632 case OMP_CLAUSE_DEPEND_OUT
:
633 pp_string (pp
, "out");
635 case OMP_CLAUSE_DEPEND_INOUT
:
636 pp_string (pp
, "inout");
638 case OMP_CLAUSE_DEPEND_SOURCE
:
639 pp_string (pp
, "source)");
641 case OMP_CLAUSE_DEPEND_SINK
:
642 pp_string (pp
, "sink:");
643 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
644 if (TREE_CODE (t
) == TREE_LIST
)
646 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
647 if (TREE_PURPOSE (t
) != integer_zero_node
)
649 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
653 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
667 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
673 pp_string (pp
, "map(");
674 switch (OMP_CLAUSE_MAP_KIND (clause
))
677 case GOMP_MAP_POINTER
:
678 pp_string (pp
, "alloc");
681 case GOMP_MAP_TO_PSET
:
682 pp_string (pp
, "to");
685 pp_string (pp
, "from");
687 case GOMP_MAP_TOFROM
:
688 pp_string (pp
, "tofrom");
690 case GOMP_MAP_FORCE_ALLOC
:
691 pp_string (pp
, "force_alloc");
693 case GOMP_MAP_FORCE_TO
:
694 pp_string (pp
, "force_to");
696 case GOMP_MAP_FORCE_FROM
:
697 pp_string (pp
, "force_from");
699 case GOMP_MAP_FORCE_TOFROM
:
700 pp_string (pp
, "force_tofrom");
702 case GOMP_MAP_FORCE_PRESENT
:
703 pp_string (pp
, "force_present");
705 case GOMP_MAP_DELETE
:
706 pp_string (pp
, "delete");
708 case GOMP_MAP_FORCE_DEVICEPTR
:
709 pp_string (pp
, "force_deviceptr");
711 case GOMP_MAP_ALWAYS_TO
:
712 pp_string (pp
, "always,to");
714 case GOMP_MAP_ALWAYS_FROM
:
715 pp_string (pp
, "always,from");
717 case GOMP_MAP_ALWAYS_TOFROM
:
718 pp_string (pp
, "always,tofrom");
720 case GOMP_MAP_RELEASE
:
721 pp_string (pp
, "release");
723 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
724 pp_string (pp
, "firstprivate");
726 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
727 pp_string (pp
, "firstprivate ref");
729 case GOMP_MAP_STRUCT
:
730 pp_string (pp
, "struct");
732 case GOMP_MAP_ALWAYS_POINTER
:
733 pp_string (pp
, "always_pointer");
735 case GOMP_MAP_DEVICE_RESIDENT
:
736 pp_string (pp
, "device_resident");
739 pp_string (pp
, "link");
745 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
748 if (OMP_CLAUSE_SIZE (clause
))
750 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
751 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
753 case GOMP_MAP_POINTER
:
754 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
755 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
756 case GOMP_MAP_ALWAYS_POINTER
:
757 pp_string (pp
, " [pointer assign, bias: ");
759 case GOMP_MAP_TO_PSET
:
760 pp_string (pp
, " [pointer set, len: ");
763 pp_string (pp
, " [len: ");
766 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
768 pp_right_bracket (pp
);
773 case OMP_CLAUSE_FROM
:
774 pp_string (pp
, "from(");
775 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
777 goto print_clause_size
;
780 pp_string (pp
, "to(");
781 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
783 goto print_clause_size
;
785 case OMP_CLAUSE__CACHE_
:
787 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
789 goto print_clause_size
;
791 case OMP_CLAUSE_NUM_TEAMS
:
792 pp_string (pp
, "num_teams(");
793 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
798 case OMP_CLAUSE_THREAD_LIMIT
:
799 pp_string (pp
, "thread_limit(");
800 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
805 case OMP_CLAUSE_DEVICE
:
806 pp_string (pp
, "device(");
807 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
812 case OMP_CLAUSE_DIST_SCHEDULE
:
813 pp_string (pp
, "dist_schedule(static");
814 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
817 dump_generic_node (pp
,
818 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
824 case OMP_CLAUSE_PROC_BIND
:
825 pp_string (pp
, "proc_bind(");
826 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
828 case OMP_CLAUSE_PROC_BIND_MASTER
:
829 pp_string (pp
, "master");
831 case OMP_CLAUSE_PROC_BIND_CLOSE
:
832 pp_string (pp
, "close");
834 case OMP_CLAUSE_PROC_BIND_SPREAD
:
835 pp_string (pp
, "spread");
843 case OMP_CLAUSE_SAFELEN
:
844 pp_string (pp
, "safelen(");
845 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
850 case OMP_CLAUSE_SIMDLEN
:
851 pp_string (pp
, "simdlen(");
852 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
857 case OMP_CLAUSE_PRIORITY
:
858 pp_string (pp
, "priority(");
859 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
864 case OMP_CLAUSE_GRAINSIZE
:
865 pp_string (pp
, "grainsize(");
866 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
871 case OMP_CLAUSE_NUM_TASKS
:
872 pp_string (pp
, "num_tasks(");
873 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
878 case OMP_CLAUSE_HINT
:
879 pp_string (pp
, "hint(");
880 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
885 case OMP_CLAUSE_DEFAULTMAP
:
886 pp_string (pp
, "defaultmap(tofrom:scalar)");
889 case OMP_CLAUSE__SIMDUID_
:
890 pp_string (pp
, "_simduid_(");
891 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
896 case OMP_CLAUSE__SIMT_
:
897 pp_string (pp
, "_simt_");
900 case OMP_CLAUSE_GANG
:
901 pp_string (pp
, "gang");
902 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
904 pp_string (pp
, "(num: ");
905 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
908 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
910 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
914 pp_string (pp
, "static:");
915 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
916 == integer_minus_one_node
)
917 pp_character (pp
, '*');
919 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
922 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
923 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
927 case OMP_CLAUSE_ASYNC
:
928 pp_string (pp
, "async");
929 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
931 pp_character(pp
, '(');
932 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
934 pp_character(pp
, ')');
938 case OMP_CLAUSE_AUTO
:
940 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
943 case OMP_CLAUSE_WAIT
:
944 pp_string (pp
, "wait(");
945 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
947 pp_character(pp
, ')');
950 case OMP_CLAUSE_WORKER
:
951 pp_string (pp
, "worker");
952 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
955 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
961 case OMP_CLAUSE_VECTOR
:
962 pp_string (pp
, "vector");
963 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
966 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
972 case OMP_CLAUSE_NUM_GANGS
:
973 pp_string (pp
, "num_gangs(");
974 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
976 pp_character (pp
, ')');
979 case OMP_CLAUSE_NUM_WORKERS
:
980 pp_string (pp
, "num_workers(");
981 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
983 pp_character (pp
, ')');
986 case OMP_CLAUSE_VECTOR_LENGTH
:
987 pp_string (pp
, "vector_length(");
988 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
990 pp_character (pp
, ')');
993 case OMP_CLAUSE_INBRANCH
:
994 pp_string (pp
, "inbranch");
996 case OMP_CLAUSE_NOTINBRANCH
:
997 pp_string (pp
, "notinbranch");
1000 pp_string (pp
, "for");
1002 case OMP_CLAUSE_PARALLEL
:
1003 pp_string (pp
, "parallel");
1005 case OMP_CLAUSE_SECTIONS
:
1006 pp_string (pp
, "sections");
1008 case OMP_CLAUSE_TASKGROUP
:
1009 pp_string (pp
, "taskgroup");
1011 case OMP_CLAUSE_NOGROUP
:
1012 pp_string (pp
, "nogroup");
1014 case OMP_CLAUSE_THREADS
:
1015 pp_string (pp
, "threads");
1017 case OMP_CLAUSE_SIMD
:
1018 pp_string (pp
, "simd");
1020 case OMP_CLAUSE_INDEPENDENT
:
1021 pp_string (pp
, "independent");
1023 case OMP_CLAUSE_TILE
:
1024 pp_string (pp
, "tile(");
1025 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1027 pp_right_paren (pp
);
1030 case OMP_CLAUSE__GRIDDIM_
:
1031 pp_string (pp
, "_griddim_(");
1032 pp_unsigned_wide_integer (pp
, OMP_CLAUSE__GRIDDIM__DIMENSION (clause
));
1034 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__SIZE (clause
), spc
, flags
,
1037 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__GROUP (clause
), spc
, flags
,
1039 pp_right_paren (pp
);
1043 /* Should never happen. */
1044 dump_generic_node (pp
, clause
, spc
, flags
, false);
1050 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1051 dump_generic_node. */
1054 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, int flags
)
1062 dump_omp_clause (pp
, clause
, spc
, flags
);
1063 clause
= OMP_CLAUSE_CHAIN (clause
);
1071 /* Dump location LOC to PP. */
1074 dump_location (pretty_printer
*pp
, location_t loc
)
1076 expanded_location xloc
= expand_location (loc
);
1078 pp_left_bracket (pp
);
1081 pp_string (pp
, xloc
.file
);
1082 pp_string (pp
, ":");
1084 pp_decimal_int (pp
, xloc
.line
);
1086 pp_decimal_int (pp
, xloc
.column
);
1087 pp_string (pp
, "] ");
1091 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1092 dump_generic_node. */
1095 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, int flags
)
1099 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1101 if (flags
& TDF_ADDRESS
)
1102 pp_printf (pp
, "[%p] ", (void *) block
);
1104 if (BLOCK_ABSTRACT (block
))
1105 pp_string (pp
, "[abstract] ");
1107 if (TREE_ASM_WRITTEN (block
))
1108 pp_string (pp
, "[written] ");
1110 if (flags
& TDF_SLIM
)
1113 if (BLOCK_SOURCE_LOCATION (block
))
1114 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1116 newline_and_indent (pp
, spc
+ 2);
1118 if (BLOCK_SUPERCONTEXT (block
))
1120 pp_string (pp
, "SUPERCONTEXT: ");
1121 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1122 flags
| TDF_SLIM
, false);
1123 newline_and_indent (pp
, spc
+ 2);
1126 if (BLOCK_SUBBLOCKS (block
))
1128 pp_string (pp
, "SUBBLOCKS: ");
1129 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1131 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1134 newline_and_indent (pp
, spc
+ 2);
1137 if (BLOCK_CHAIN (block
))
1139 pp_string (pp
, "SIBLINGS: ");
1140 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1142 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1145 newline_and_indent (pp
, spc
+ 2);
1148 if (BLOCK_VARS (block
))
1150 pp_string (pp
, "VARS: ");
1151 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1153 dump_generic_node (pp
, t
, 0, flags
, false);
1156 newline_and_indent (pp
, spc
+ 2);
1159 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1162 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1164 pp_string (pp
, "NONLOCALIZED_VARS: ");
1165 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1167 dump_generic_node (pp
, t
, 0, flags
, false);
1170 newline_and_indent (pp
, spc
+ 2);
1173 if (BLOCK_ABSTRACT_ORIGIN (block
))
1175 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1176 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1177 flags
| TDF_SLIM
, false);
1178 newline_and_indent (pp
, spc
+ 2);
1181 if (BLOCK_FRAGMENT_ORIGIN (block
))
1183 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1184 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1185 flags
| TDF_SLIM
, false);
1186 newline_and_indent (pp
, spc
+ 2);
1189 if (BLOCK_FRAGMENT_CHAIN (block
))
1191 pp_string (pp
, "FRAGMENT_CHAIN: ");
1192 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1194 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1197 newline_and_indent (pp
, spc
+ 2);
1202 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1203 indent. FLAGS specifies details to show in the dump (see TDF_* in
1204 dumpfile.h). If IS_STMT is true, the object printed is considered
1205 to be a statement and it is terminated by ';' if appropriate. */
1208 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, int flags
,
1215 enum tree_code code
;
1217 if (node
== NULL_TREE
)
1220 is_expr
= EXPR_P (node
);
1222 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1223 pp_printf (pp
, "<&%p> ", (void *)node
);
1225 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1226 dump_location (pp
, EXPR_LOCATION (node
));
1228 code
= TREE_CODE (node
);
1232 pp_string (pp
, "<<< error >>>");
1235 case IDENTIFIER_NODE
:
1236 pp_tree_identifier (pp
, node
);
1240 while (node
&& node
!= error_mark_node
)
1242 if (TREE_PURPOSE (node
))
1244 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1247 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1248 node
= TREE_CHAIN (node
);
1249 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1258 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1264 if (TREE_VEC_LENGTH (node
) > 0)
1266 size_t len
= TREE_VEC_LENGTH (node
);
1267 for (i
= 0; i
< len
- 1; i
++)
1269 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1274 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1281 case POINTER_BOUNDS_TYPE
:
1284 case FIXED_POINT_TYPE
:
1290 unsigned int quals
= TYPE_QUALS (node
);
1291 enum tree_code_class tclass
;
1293 if (quals
& TYPE_QUAL_ATOMIC
)
1294 pp_string (pp
, "atomic ");
1295 if (quals
& TYPE_QUAL_CONST
)
1296 pp_string (pp
, "const ");
1297 else if (quals
& TYPE_QUAL_VOLATILE
)
1298 pp_string (pp
, "volatile ");
1299 else if (quals
& TYPE_QUAL_RESTRICT
)
1300 pp_string (pp
, "restrict ");
1302 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1304 pp_string (pp
, "<address-space-");
1305 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1306 pp_string (pp
, "> ");
1309 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1311 if (tclass
== tcc_declaration
)
1313 if (DECL_NAME (node
))
1314 dump_decl_name (pp
, node
, flags
);
1316 pp_string (pp
, "<unnamed type decl>");
1318 else if (tclass
== tcc_type
)
1320 if (TYPE_NAME (node
))
1322 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1323 pp_tree_identifier (pp
, TYPE_NAME (node
));
1324 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1325 && DECL_NAME (TYPE_NAME (node
)))
1326 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1328 pp_string (pp
, "<unnamed type>");
1330 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1332 pp_string (pp
, "vector");
1334 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1335 pp_string (pp
, ") ");
1336 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1338 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1340 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1341 pp_string (pp
, (TYPE_UNSIGNED (node
)
1344 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1345 pp_string (pp
, (TYPE_UNSIGNED (node
)
1348 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1349 pp_string (pp
, (TYPE_UNSIGNED (node
)
1352 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1353 pp_string (pp
, (TYPE_UNSIGNED (node
)
1356 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1357 pp_string (pp
, (TYPE_UNSIGNED (node
)
1358 ? "unsigned long long"
1359 : "signed long long"));
1360 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1361 && pow2p_hwi (TYPE_PRECISION (node
)))
1363 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1364 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1365 pp_string (pp
, "_t");
1369 pp_string (pp
, (TYPE_UNSIGNED (node
)
1370 ? "<unnamed-unsigned:"
1371 : "<unnamed-signed:"));
1372 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1376 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1378 pp_string (pp
, "__complex__ ");
1379 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1381 else if (TREE_CODE (node
) == REAL_TYPE
)
1383 pp_string (pp
, "<float:");
1384 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1387 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1389 pp_string (pp
, "<fixed-point-");
1390 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1391 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1394 else if (TREE_CODE (node
) == VOID_TYPE
)
1395 pp_string (pp
, "void");
1397 pp_string (pp
, "<unnamed type>");
1403 case REFERENCE_TYPE
:
1404 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1406 if (TREE_TYPE (node
) == NULL
)
1408 pp_string (pp
, str
);
1409 pp_string (pp
, "<null type>");
1411 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1413 tree fnode
= TREE_TYPE (node
);
1415 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1418 pp_string (pp
, str
);
1419 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1420 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1421 else if (flags
& TDF_NOUID
)
1422 pp_printf (pp
, "<Txxxx>");
1424 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1426 pp_right_paren (pp
);
1427 dump_function_declaration (pp
, fnode
, spc
, flags
);
1431 unsigned int quals
= TYPE_QUALS (node
);
1433 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1435 pp_string (pp
, str
);
1437 if (quals
& TYPE_QUAL_CONST
)
1438 pp_string (pp
, " const");
1439 if (quals
& TYPE_QUAL_VOLATILE
)
1440 pp_string (pp
, " volatile");
1441 if (quals
& TYPE_QUAL_RESTRICT
)
1442 pp_string (pp
, " restrict");
1444 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1446 pp_string (pp
, " <address-space-");
1447 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1451 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1452 pp_string (pp
, " {ref-all}");
1462 if (integer_zerop (TREE_OPERAND (node
, 1))
1463 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1464 infer them and MEM_ATTR caching will share MEM_REFs
1465 with differently-typed op0s. */
1466 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1467 /* Released SSA_NAMES have no TREE_TYPE. */
1468 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1469 /* Same pointer types, but ignoring POINTER_TYPE vs.
1471 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1472 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1473 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1474 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1475 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1476 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1477 /* Same value types ignoring qualifiers. */
1478 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1479 == TYPE_MAIN_VARIANT
1480 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1481 && (!(flags
& TDF_ALIAS
)
1482 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1484 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1487 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1491 dump_generic_node (pp
,
1492 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1499 pp_string (pp
, "MEM[");
1501 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1502 dump_generic_node (pp
, ptype
,
1503 spc
, flags
| TDF_SLIM
, false);
1504 pp_right_paren (pp
);
1505 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1507 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1509 pp_string (pp
, " + ");
1510 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1513 if ((flags
& TDF_ALIAS
)
1514 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1516 pp_string (pp
, " clique ");
1517 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1518 pp_string (pp
, " base ");
1519 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1521 pp_right_bracket (pp
);
1526 case TARGET_MEM_REF
:
1528 const char *sep
= "";
1531 pp_string (pp
, "MEM[");
1533 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1535 pp_string (pp
, sep
);
1537 pp_string (pp
, "symbol: ");
1538 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1543 pp_string (pp
, sep
);
1545 pp_string (pp
, "base: ");
1546 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1548 tmp
= TMR_INDEX2 (node
);
1551 pp_string (pp
, sep
);
1553 pp_string (pp
, "base: ");
1554 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1556 tmp
= TMR_INDEX (node
);
1559 pp_string (pp
, sep
);
1561 pp_string (pp
, "index: ");
1562 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1564 tmp
= TMR_STEP (node
);
1567 pp_string (pp
, sep
);
1569 pp_string (pp
, "step: ");
1570 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1572 tmp
= TMR_OFFSET (node
);
1575 pp_string (pp
, sep
);
1577 pp_string (pp
, "offset: ");
1578 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1580 pp_right_bracket (pp
);
1588 /* Print the innermost component type. */
1589 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1590 tmp
= TREE_TYPE (tmp
))
1592 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1594 /* Print the dimensions. */
1595 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1596 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1602 case QUAL_UNION_TYPE
:
1604 unsigned int quals
= TYPE_QUALS (node
);
1606 if (quals
& TYPE_QUAL_ATOMIC
)
1607 pp_string (pp
, "atomic ");
1608 if (quals
& TYPE_QUAL_CONST
)
1609 pp_string (pp
, "const ");
1610 if (quals
& TYPE_QUAL_VOLATILE
)
1611 pp_string (pp
, "volatile ");
1613 /* Print the name of the structure. */
1614 if (TREE_CODE (node
) == RECORD_TYPE
)
1615 pp_string (pp
, "struct ");
1616 else if (TREE_CODE (node
) == UNION_TYPE
)
1617 pp_string (pp
, "union ");
1619 if (TYPE_NAME (node
))
1620 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1621 else if (!(flags
& TDF_SLIM
))
1622 /* FIXME: If we eliminate the 'else' above and attempt
1623 to show the fields for named types, we may get stuck
1624 following a cycle of pointers to structs. The alleged
1625 self-reference check in print_struct_decl will not detect
1626 cycles involving more than one pointer or struct type. */
1627 print_struct_decl (pp
, node
, spc
, flags
);
1636 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
1638 /* In the case of a pointer, one may want to divide by the
1639 size of the pointed-to type. Unfortunately, this not
1640 straightforward. The C front-end maps expressions
1645 in such a way that the two INTEGER_CST nodes for "5" have
1646 different values but identical types. In the latter
1647 case, the 5 is multiplied by sizeof (int) in c-common.c
1648 (pointer_int_sum) to convert it to a byte address, and
1649 yet the type of the node is left unchanged. Argh. What
1650 is consistent though is that the number value corresponds
1651 to bytes (UNITS) offset.
1653 NB: Neither of the following divisors can be trivially
1654 used to recover the original literal:
1656 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1657 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1658 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1659 pp_string (pp
, "B"); /* pseudo-unit */
1661 else if (tree_fits_shwi_p (node
))
1662 pp_wide_integer (pp
, tree_to_shwi (node
));
1663 else if (tree_fits_uhwi_p (node
))
1664 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1667 wide_int val
= node
;
1669 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1674 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
1675 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
1677 if (TREE_OVERFLOW (node
))
1678 pp_string (pp
, "(OVF)");
1682 /* Code copied from print_node. */
1685 if (TREE_OVERFLOW (node
))
1686 pp_string (pp
, " overflow");
1688 d
= TREE_REAL_CST (node
);
1689 if (REAL_VALUE_ISINF (d
))
1690 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1691 else if (REAL_VALUE_ISNAN (d
))
1692 pp_string (pp
, " Nan");
1696 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1697 pp_string (pp
, string
);
1705 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1706 pp_string (pp
, string
);
1711 pp_string (pp
, "__complex__ (");
1712 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
1713 pp_string (pp
, ", ");
1714 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
1715 pp_right_paren (pp
);
1719 pp_string (pp
, "\"");
1720 pretty_print_string (pp
, TREE_STRING_POINTER (node
));
1721 pp_string (pp
, "\"");
1727 pp_string (pp
, "{ ");
1728 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1731 pp_string (pp
, ", ");
1732 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
1735 pp_string (pp
, " }");
1741 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1743 if (TREE_CODE (node
) == METHOD_TYPE
)
1745 if (TYPE_METHOD_BASETYPE (node
))
1746 dump_decl_name (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1749 pp_string (pp
, "<null method basetype>");
1750 pp_colon_colon (pp
);
1752 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1753 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1754 else if (flags
& TDF_NOUID
)
1755 pp_printf (pp
, "<Txxxx>");
1757 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1758 dump_function_declaration (pp
, node
, spc
, flags
);
1763 dump_decl_name (pp
, node
, flags
);
1767 if (DECL_NAME (node
))
1768 dump_decl_name (pp
, node
, flags
);
1769 else if (LABEL_DECL_UID (node
) != -1)
1771 if (flags
& TDF_GIMPLE
)
1772 pp_printf (pp
, "L%d", (int) LABEL_DECL_UID (node
));
1774 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
1778 if (flags
& TDF_NOUID
)
1779 pp_string (pp
, "<D.xxxx>");
1782 if (flags
& TDF_GIMPLE
)
1783 pp_printf (pp
, "<D%u>", DECL_UID (node
));
1785 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
1791 if (DECL_IS_BUILTIN (node
))
1793 /* Don't print the declaration of built-in types. */
1796 if (DECL_NAME (node
))
1797 dump_decl_name (pp
, node
, flags
);
1798 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1800 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1801 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1802 && TYPE_METHODS (TREE_TYPE (node
)))
1804 /* The type is a c++ class: all structures have at least
1806 pp_string (pp
, "class ");
1807 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1812 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1813 ? "union" : "struct "));
1814 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1818 pp_string (pp
, "<anon>");
1824 case DEBUG_EXPR_DECL
:
1825 case NAMESPACE_DECL
:
1827 dump_decl_name (pp
, node
, flags
);
1831 pp_string (pp
, "<retval>");
1835 op0
= TREE_OPERAND (node
, 0);
1838 && (TREE_CODE (op0
) == INDIRECT_REF
1839 || (TREE_CODE (op0
) == MEM_REF
1840 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1841 && integer_zerop (TREE_OPERAND (op0
, 1))
1842 /* Dump the types of INTEGER_CSTs explicitly, for we
1843 can't infer them and MEM_ATTR caching will share
1844 MEM_REFs with differently-typed op0s. */
1845 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1846 /* Released SSA_NAMES have no TREE_TYPE. */
1847 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1848 /* Same pointer types, but ignoring POINTER_TYPE vs.
1850 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1851 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1852 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1853 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1854 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1855 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1856 /* Same value types ignoring qualifiers. */
1857 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1858 == TYPE_MAIN_VARIANT
1859 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
1860 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
1862 op0
= TREE_OPERAND (op0
, 0);
1865 if (op_prio (op0
) < op_prio (node
))
1867 dump_generic_node (pp
, op0
, spc
, flags
, false);
1868 if (op_prio (op0
) < op_prio (node
))
1869 pp_right_paren (pp
);
1870 pp_string (pp
, str
);
1871 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1872 op0
= component_ref_field_offset (node
);
1873 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1875 pp_string (pp
, "{off: ");
1876 dump_generic_node (pp
, op0
, spc
, flags
, false);
1877 pp_right_brace (pp
);
1882 pp_string (pp
, "BIT_FIELD_REF <");
1883 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1884 pp_string (pp
, ", ");
1885 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1886 pp_string (pp
, ", ");
1887 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1891 case BIT_INSERT_EXPR
:
1892 pp_string (pp
, "BIT_INSERT_EXPR <");
1893 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1894 pp_string (pp
, ", ");
1895 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1896 pp_string (pp
, ", ");
1897 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1898 pp_string (pp
, " (");
1899 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
1901 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
1903 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
1905 pp_string (pp
, " bits)>");
1909 case ARRAY_RANGE_REF
:
1910 op0
= TREE_OPERAND (node
, 0);
1911 if (op_prio (op0
) < op_prio (node
))
1913 dump_generic_node (pp
, op0
, spc
, flags
, false);
1914 if (op_prio (op0
) < op_prio (node
))
1915 pp_right_paren (pp
);
1916 pp_left_bracket (pp
);
1917 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1918 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1919 pp_string (pp
, " ...");
1920 pp_right_bracket (pp
);
1922 op0
= array_ref_low_bound (node
);
1923 op1
= array_ref_element_size (node
);
1925 if (!integer_zerop (op0
)
1926 || TREE_OPERAND (node
, 2)
1927 || TREE_OPERAND (node
, 3))
1929 pp_string (pp
, "{lb: ");
1930 dump_generic_node (pp
, op0
, spc
, flags
, false);
1931 pp_string (pp
, " sz: ");
1932 dump_generic_node (pp
, op1
, spc
, flags
, false);
1933 pp_right_brace (pp
);
1939 unsigned HOST_WIDE_INT ix
;
1941 bool is_struct_init
= false;
1942 bool is_array_init
= false;
1945 if (TREE_CLOBBER_P (node
))
1946 pp_string (pp
, "CLOBBER");
1947 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1948 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1949 is_struct_init
= true;
1950 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
1951 && TYPE_DOMAIN (TREE_TYPE (node
))
1952 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
1953 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
1956 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
1957 is_array_init
= true;
1958 curidx
= wi::to_widest (minv
);
1960 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1967 dump_generic_node (pp
, field
, spc
, flags
, false);
1970 else if (is_array_init
1971 && (TREE_CODE (field
) != INTEGER_CST
1972 || curidx
!= wi::to_widest (field
)))
1974 pp_left_bracket (pp
);
1975 if (TREE_CODE (field
) == RANGE_EXPR
)
1977 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
1979 pp_string (pp
, " ... ");
1980 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
1982 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
1983 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
1986 dump_generic_node (pp
, field
, spc
, flags
, false);
1987 if (TREE_CODE (field
) == INTEGER_CST
)
1988 curidx
= wi::to_widest (field
);
1989 pp_string (pp
, "]=");
1994 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1995 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1996 val
= TREE_OPERAND (val
, 0);
1997 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1998 dump_decl_name (pp
, val
, flags
);
2000 dump_generic_node (pp
, val
, spc
, flags
, false);
2001 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2007 pp_right_brace (pp
);
2014 if (flags
& TDF_SLIM
)
2016 pp_string (pp
, "<COMPOUND_EXPR>");
2020 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2021 spc
, flags
, !(flags
& TDF_SLIM
));
2022 if (flags
& TDF_SLIM
)
2023 newline_and_indent (pp
, spc
);
2030 for (tp
= &TREE_OPERAND (node
, 1);
2031 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2032 tp
= &TREE_OPERAND (*tp
, 1))
2034 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2035 spc
, flags
, !(flags
& TDF_SLIM
));
2036 if (flags
& TDF_SLIM
)
2037 newline_and_indent (pp
, spc
);
2045 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2049 case STATEMENT_LIST
:
2051 tree_stmt_iterator si
;
2054 if (flags
& TDF_SLIM
)
2056 pp_string (pp
, "<STATEMENT_LIST>");
2060 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2063 newline_and_indent (pp
, spc
);
2066 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2073 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2078 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2083 pp_string (pp
, "TARGET_EXPR <");
2084 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2087 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2092 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2097 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2099 pp_string (pp
, "if (");
2100 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2101 pp_right_paren (pp
);
2102 /* The lowered cond_exprs should always be printed in full. */
2103 if (COND_EXPR_THEN (node
)
2104 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2105 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2106 && COND_EXPR_ELSE (node
)
2107 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2108 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2111 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2113 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2115 pp_string (pp
, " else ");
2116 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2120 else if (!(flags
& TDF_SLIM
))
2122 /* Output COND_EXPR_THEN. */
2123 if (COND_EXPR_THEN (node
))
2125 newline_and_indent (pp
, spc
+2);
2127 newline_and_indent (pp
, spc
+4);
2128 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2130 newline_and_indent (pp
, spc
+2);
2131 pp_right_brace (pp
);
2134 /* Output COND_EXPR_ELSE. */
2135 if (COND_EXPR_ELSE (node
)
2136 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2138 newline_and_indent (pp
, spc
);
2139 pp_string (pp
, "else");
2140 newline_and_indent (pp
, spc
+2);
2142 newline_and_indent (pp
, spc
+4);
2143 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2145 newline_and_indent (pp
, spc
+2);
2146 pp_right_brace (pp
);
2153 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2157 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2161 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2167 if (!(flags
& TDF_SLIM
))
2169 if (BIND_EXPR_VARS (node
))
2173 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2175 print_declaration (pp
, op0
, spc
+2, flags
);
2180 newline_and_indent (pp
, spc
+2);
2181 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2182 newline_and_indent (pp
, spc
);
2183 pp_right_brace (pp
);
2189 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2190 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2192 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2194 /* Print parameters. */
2199 call_expr_arg_iterator iter
;
2200 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2202 dump_generic_node (pp
, arg
, spc
, flags
, false);
2203 if (more_call_expr_args_p (&iter
))
2210 if (CALL_EXPR_VA_ARG_PACK (node
))
2212 if (call_expr_nargs (node
) > 0)
2217 pp_string (pp
, "__builtin_va_arg_pack ()");
2219 pp_right_paren (pp
);
2221 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2224 pp_string (pp
, " [static-chain: ");
2225 dump_generic_node (pp
, op1
, spc
, flags
, false);
2226 pp_right_bracket (pp
);
2229 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2230 pp_string (pp
, " [return slot optimization]");
2231 if (CALL_EXPR_TAILCALL (node
))
2232 pp_string (pp
, " [tail call]");
2235 case WITH_CLEANUP_EXPR
:
2239 case CLEANUP_POINT_EXPR
:
2240 pp_string (pp
, "<<cleanup_point ");
2241 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2242 pp_string (pp
, ">>");
2245 case PLACEHOLDER_EXPR
:
2246 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2247 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2251 /* Binary arithmetic and logic expressions. */
2252 case WIDEN_SUM_EXPR
:
2253 case WIDEN_MULT_EXPR
:
2255 case MULT_HIGHPART_EXPR
:
2257 case POINTER_PLUS_EXPR
:
2259 case TRUNC_DIV_EXPR
:
2261 case FLOOR_DIV_EXPR
:
2262 case ROUND_DIV_EXPR
:
2263 case TRUNC_MOD_EXPR
:
2265 case FLOOR_MOD_EXPR
:
2266 case ROUND_MOD_EXPR
:
2268 case EXACT_DIV_EXPR
:
2273 case WIDEN_LSHIFT_EXPR
:
2277 case TRUTH_ANDIF_EXPR
:
2278 case TRUTH_ORIF_EXPR
:
2279 case TRUTH_AND_EXPR
:
2281 case TRUTH_XOR_EXPR
:
2295 case UNORDERED_EXPR
:
2297 const char *op
= op_symbol (node
);
2298 op0
= TREE_OPERAND (node
, 0);
2299 op1
= TREE_OPERAND (node
, 1);
2301 /* When the operands are expressions with less priority,
2302 keep semantics of the tree representation. */
2303 if (op_prio (op0
) <= op_prio (node
))
2306 dump_generic_node (pp
, op0
, spc
, flags
, false);
2307 pp_right_paren (pp
);
2310 dump_generic_node (pp
, op0
, spc
, flags
, false);
2316 /* When the operands are expressions with less priority,
2317 keep semantics of the tree representation. */
2318 if (op_prio (op1
) <= op_prio (node
))
2321 dump_generic_node (pp
, op1
, spc
, flags
, false);
2322 pp_right_paren (pp
);
2325 dump_generic_node (pp
, op1
, spc
, flags
, false);
2329 /* Unary arithmetic and logic expressions. */
2332 case TRUTH_NOT_EXPR
:
2334 case PREDECREMENT_EXPR
:
2335 case PREINCREMENT_EXPR
:
2337 if (TREE_CODE (node
) == ADDR_EXPR
2338 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2339 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2340 ; /* Do not output '&' for strings and function pointers. */
2342 pp_string (pp
, op_symbol (node
));
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);
2354 case POSTDECREMENT_EXPR
:
2355 case POSTINCREMENT_EXPR
:
2356 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2359 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2360 pp_right_paren (pp
);
2363 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2364 pp_string (pp
, op_symbol (node
));
2368 pp_string (pp
, "MIN_EXPR <");
2369 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2370 pp_string (pp
, ", ");
2371 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2376 pp_string (pp
, "MAX_EXPR <");
2377 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2378 pp_string (pp
, ", ");
2379 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2384 pp_string (pp
, "ABS_EXPR <");
2385 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2393 case ADDR_SPACE_CONVERT_EXPR
:
2394 case FIXED_CONVERT_EXPR
:
2395 case FIX_TRUNC_EXPR
:
2398 type
= TREE_TYPE (node
);
2399 op0
= TREE_OPERAND (node
, 0);
2400 if (type
!= TREE_TYPE (op0
))
2403 dump_generic_node (pp
, type
, spc
, flags
, false);
2404 pp_string (pp
, ") ");
2406 if (op_prio (op0
) < op_prio (node
))
2408 dump_generic_node (pp
, op0
, spc
, flags
, false);
2409 if (op_prio (op0
) < op_prio (node
))
2410 pp_right_paren (pp
);
2413 case VIEW_CONVERT_EXPR
:
2414 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2415 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2416 pp_string (pp
, ">(");
2417 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2418 pp_right_paren (pp
);
2422 pp_string (pp
, "((");
2423 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2424 pp_string (pp
, "))");
2427 case NON_LVALUE_EXPR
:
2428 pp_string (pp
, "NON_LVALUE_EXPR <");
2429 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2434 pp_string (pp
, "SAVE_EXPR <");
2435 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2440 pp_string (pp
, "COMPLEX_EXPR <");
2441 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2442 pp_string (pp
, ", ");
2443 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2448 pp_string (pp
, "CONJ_EXPR <");
2449 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2454 pp_string (pp
, "REALPART_EXPR <");
2455 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2460 pp_string (pp
, "IMAGPART_EXPR <");
2461 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2466 pp_string (pp
, "VA_ARG_EXPR <");
2467 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2471 case TRY_FINALLY_EXPR
:
2472 case TRY_CATCH_EXPR
:
2473 pp_string (pp
, "try");
2474 newline_and_indent (pp
, spc
+2);
2476 newline_and_indent (pp
, spc
+4);
2477 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2478 newline_and_indent (pp
, spc
+2);
2479 pp_right_brace (pp
);
2480 newline_and_indent (pp
, spc
);
2482 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2483 newline_and_indent (pp
, spc
+2);
2485 newline_and_indent (pp
, spc
+4);
2486 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2487 newline_and_indent (pp
, spc
+2);
2488 pp_right_brace (pp
);
2493 pp_string (pp
, "catch (");
2494 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2495 pp_right_paren (pp
);
2496 newline_and_indent (pp
, spc
+2);
2498 newline_and_indent (pp
, spc
+4);
2499 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2500 newline_and_indent (pp
, spc
+2);
2501 pp_right_brace (pp
);
2505 case EH_FILTER_EXPR
:
2506 pp_string (pp
, "<<<eh_filter (");
2507 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2508 pp_string (pp
, ")>>>");
2509 newline_and_indent (pp
, spc
+2);
2511 newline_and_indent (pp
, spc
+4);
2512 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2513 newline_and_indent (pp
, spc
+2);
2514 pp_right_brace (pp
);
2519 op0
= TREE_OPERAND (node
, 0);
2520 /* If this is for break or continue, don't bother printing it. */
2521 if (DECL_NAME (op0
))
2523 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2524 if (strcmp (name
, "break") == 0
2525 || strcmp (name
, "continue") == 0)
2528 dump_generic_node (pp
, op0
, spc
, flags
, false);
2530 if (DECL_NONLOCAL (op0
))
2531 pp_string (pp
, " [non-local]");
2535 pp_string (pp
, "while (1)");
2536 if (!(flags
& TDF_SLIM
))
2538 newline_and_indent (pp
, spc
+2);
2540 newline_and_indent (pp
, spc
+4);
2541 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2542 newline_and_indent (pp
, spc
+2);
2543 pp_right_brace (pp
);
2549 pp_string (pp
, "// predicted ");
2550 if (PREDICT_EXPR_OUTCOME (node
))
2551 pp_string (pp
, "likely by ");
2553 pp_string (pp
, "unlikely by ");
2554 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2555 pp_string (pp
, " predictor.");
2559 pp_string (pp
, "ANNOTATE_EXPR <");
2560 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2561 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2563 case annot_expr_ivdep_kind
:
2564 pp_string (pp
, ", ivdep");
2566 case annot_expr_no_vector_kind
:
2567 pp_string (pp
, ", no-vector");
2569 case annot_expr_vector_kind
:
2570 pp_string (pp
, ", vector");
2579 pp_string (pp
, "return");
2580 op0
= TREE_OPERAND (node
, 0);
2584 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2585 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2588 dump_generic_node (pp
, op0
, spc
, flags
, false);
2593 pp_string (pp
, "if (");
2594 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2595 pp_string (pp
, ") break");
2599 pp_string (pp
, "switch (");
2600 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2601 pp_right_paren (pp
);
2602 if (!(flags
& TDF_SLIM
))
2604 newline_and_indent (pp
, spc
+2);
2606 if (SWITCH_BODY (node
))
2608 newline_and_indent (pp
, spc
+4);
2609 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2614 tree vec
= SWITCH_LABELS (node
);
2615 size_t i
, n
= TREE_VEC_LENGTH (vec
);
2616 for (i
= 0; i
< n
; ++i
)
2618 tree elt
= TREE_VEC_ELT (vec
, i
);
2619 newline_and_indent (pp
, spc
+4);
2622 dump_generic_node (pp
, elt
, spc
+4, flags
, false);
2623 pp_string (pp
, " goto ");
2624 dump_generic_node (pp
, CASE_LABEL (elt
), spc
+4,
2629 pp_string (pp
, "case ???: goto ???;");
2632 newline_and_indent (pp
, spc
+2);
2633 pp_right_brace (pp
);
2639 op0
= GOTO_DESTINATION (node
);
2640 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2642 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2643 if (strcmp (name
, "break") == 0
2644 || strcmp (name
, "continue") == 0)
2646 pp_string (pp
, name
);
2650 pp_string (pp
, "goto ");
2651 dump_generic_node (pp
, op0
, spc
, flags
, false);
2655 pp_string (pp
, "__asm__");
2656 if (ASM_VOLATILE_P (node
))
2657 pp_string (pp
, " __volatile__");
2659 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2661 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2663 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2664 if (ASM_CLOBBERS (node
))
2667 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2669 pp_right_paren (pp
);
2672 case CASE_LABEL_EXPR
:
2673 if (CASE_LOW (node
) && CASE_HIGH (node
))
2675 pp_string (pp
, "case ");
2676 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2677 pp_string (pp
, " ... ");
2678 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2680 else if (CASE_LOW (node
))
2682 pp_string (pp
, "case ");
2683 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2686 pp_string (pp
, "default");
2691 pp_string (pp
, "OBJ_TYPE_REF(");
2692 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2694 if (!(flags
& TDF_SLIM
) && virtual_method_call_p (node
))
2696 pp_string (pp
, "(");
2697 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2698 pp_string (pp
, ")");
2700 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2702 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2703 pp_right_paren (pp
);
2707 if (SSA_NAME_IDENTIFIER (node
))
2709 if ((flags
& TDF_NOUID
)
2710 && SSA_NAME_VAR (node
)
2711 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
2712 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
2713 else if (! (flags
& TDF_GIMPLE
)
2714 || SSA_NAME_VAR (node
))
2715 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2719 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2720 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2721 pp_string (pp
, "(D)");
2722 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2723 pp_string (pp
, "(ab)");
2726 case WITH_SIZE_EXPR
:
2727 pp_string (pp
, "WITH_SIZE_EXPR <");
2728 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2729 pp_string (pp
, ", ");
2730 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2735 pp_string (pp
, "ASSERT_EXPR <");
2736 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2737 pp_string (pp
, ", ");
2738 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2743 pp_string (pp
, "scev_known");
2746 case SCEV_NOT_KNOWN
:
2747 pp_string (pp
, "scev_not_known");
2750 case POLYNOMIAL_CHREC
:
2752 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2753 pp_string (pp
, ", +, ");
2754 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2755 pp_string (pp
, "}_");
2756 dump_generic_node (pp
, CHREC_VAR (node
), spc
, flags
, false);
2760 case REALIGN_LOAD_EXPR
:
2761 pp_string (pp
, "REALIGN_LOAD <");
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);
2771 pp_string (pp
, " VEC_COND_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
, " > ");
2781 pp_string (pp
, " VEC_PERM_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
, " DOT_PROD_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
, " > ");
2800 case WIDEN_MULT_PLUS_EXPR
:
2801 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
2802 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2803 pp_string (pp
, ", ");
2804 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2805 pp_string (pp
, ", ");
2806 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2807 pp_string (pp
, " > ");
2810 case WIDEN_MULT_MINUS_EXPR
:
2811 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
2812 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2813 pp_string (pp
, ", ");
2814 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2815 pp_string (pp
, ", ");
2816 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2817 pp_string (pp
, " > ");
2821 pp_string (pp
, " FMA_EXPR < ");
2822 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2823 pp_string (pp
, ", ");
2824 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2825 pp_string (pp
, ", ");
2826 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2827 pp_string (pp
, " > ");
2831 pp_string (pp
, "#pragma acc parallel");
2832 goto dump_omp_clauses_body
;
2835 pp_string (pp
, "#pragma acc kernels");
2836 goto dump_omp_clauses_body
;
2839 pp_string (pp
, "#pragma acc data");
2840 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2843 case OACC_HOST_DATA
:
2844 pp_string (pp
, "#pragma acc host_data");
2845 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2849 pp_string (pp
, "#pragma acc declare");
2850 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2854 pp_string (pp
, "#pragma acc update");
2855 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2858 case OACC_ENTER_DATA
:
2859 pp_string (pp
, "#pragma acc enter data");
2860 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2863 case OACC_EXIT_DATA
:
2864 pp_string (pp
, "#pragma acc exit data");
2865 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2869 pp_string (pp
, "#pragma acc cache");
2870 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2874 pp_string (pp
, "#pragma omp parallel");
2875 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2878 dump_omp_clauses_body
:
2879 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2883 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2885 newline_and_indent (pp
, spc
+ 2);
2887 newline_and_indent (pp
, spc
+ 4);
2888 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2889 newline_and_indent (pp
, spc
+ 2);
2890 pp_right_brace (pp
);
2896 pp_string (pp
, "#pragma omp task");
2897 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2901 pp_string (pp
, "#pragma omp for");
2905 pp_string (pp
, "#pragma omp simd");
2909 pp_string (pp
, "#pragma simd");
2913 /* This label points one line after dumping the clauses.
2914 For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2915 parameters are printed out. */
2916 goto dump_omp_loop_cilk_for
;
2918 case OMP_DISTRIBUTE
:
2919 pp_string (pp
, "#pragma omp distribute");
2923 pp_string (pp
, "#pragma omp taskloop");
2927 pp_string (pp
, "#pragma acc loop");
2931 pp_string (pp
, "#pragma omp teams");
2932 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
2935 case OMP_TARGET_DATA
:
2936 pp_string (pp
, "#pragma omp target data");
2937 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
2940 case OMP_TARGET_ENTER_DATA
:
2941 pp_string (pp
, "#pragma omp target enter data");
2942 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2946 case OMP_TARGET_EXIT_DATA
:
2947 pp_string (pp
, "#pragma omp target exit data");
2948 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2953 pp_string (pp
, "#pragma omp target");
2954 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
2957 case OMP_TARGET_UPDATE
:
2958 pp_string (pp
, "#pragma omp target update");
2959 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
2964 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2966 dump_omp_loop_cilk_for
:
2967 if (!(flags
& TDF_SLIM
))
2971 if (OMP_FOR_PRE_BODY (node
))
2973 if (TREE_CODE (node
) == CILK_FOR
)
2974 pp_string (pp
, " ");
2976 newline_and_indent (pp
, spc
+ 2);
2979 newline_and_indent (pp
, spc
);
2980 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
2983 if (OMP_FOR_INIT (node
))
2986 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
2989 if (TREE_CODE (node
) != CILK_FOR
|| OMP_FOR_PRE_BODY (node
))
2990 newline_and_indent (pp
, spc
);
2991 if (TREE_CODE (node
) == CILK_FOR
)
2992 pp_string (pp
, "_Cilk_for (");
2994 pp_string (pp
, "for (");
2995 dump_generic_node (pp
,
2996 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
2998 pp_string (pp
, "; ");
2999 dump_generic_node (pp
,
3000 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
3002 pp_string (pp
, "; ");
3003 dump_generic_node (pp
,
3004 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3006 pp_right_paren (pp
);
3008 if (TREE_CODE (node
) == CILK_FOR
)
3009 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3011 if (OMP_FOR_BODY (node
))
3013 newline_and_indent (pp
, spc
+ 2);
3015 newline_and_indent (pp
, spc
+ 4);
3016 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3018 newline_and_indent (pp
, spc
+ 2);
3019 pp_right_brace (pp
);
3021 if (OMP_FOR_INIT (node
))
3022 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3023 if (OMP_FOR_PRE_BODY (node
))
3026 newline_and_indent (pp
, spc
+ 2);
3027 pp_right_brace (pp
);
3034 pp_string (pp
, "#pragma omp sections");
3035 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3039 pp_string (pp
, "#pragma omp section");
3043 pp_string (pp
, "#pragma omp master");
3047 pp_string (pp
, "#pragma omp taskgroup");
3051 pp_string (pp
, "#pragma omp ordered");
3052 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3056 pp_string (pp
, "#pragma omp critical");
3057 if (OMP_CRITICAL_NAME (node
))
3061 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3063 pp_right_paren (pp
);
3065 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3069 pp_string (pp
, "#pragma omp atomic");
3070 if (OMP_ATOMIC_SEQ_CST (node
))
3071 pp_string (pp
, " seq_cst");
3072 newline_and_indent (pp
, spc
+ 2);
3073 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3077 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3080 case OMP_ATOMIC_READ
:
3081 pp_string (pp
, "#pragma omp atomic read");
3082 if (OMP_ATOMIC_SEQ_CST (node
))
3083 pp_string (pp
, " seq_cst");
3084 newline_and_indent (pp
, spc
+ 2);
3085 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3089 case OMP_ATOMIC_CAPTURE_OLD
:
3090 case OMP_ATOMIC_CAPTURE_NEW
:
3091 pp_string (pp
, "#pragma omp atomic capture");
3092 if (OMP_ATOMIC_SEQ_CST (node
))
3093 pp_string (pp
, " seq_cst");
3094 newline_and_indent (pp
, spc
+ 2);
3095 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3099 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3103 pp_string (pp
, "#pragma omp single");
3104 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3108 dump_omp_clause (pp
, node
, spc
, flags
);
3112 case TRANSACTION_EXPR
:
3113 if (TRANSACTION_EXPR_OUTER (node
))
3114 pp_string (pp
, "__transaction_atomic [[outer]]");
3115 else if (TRANSACTION_EXPR_RELAXED (node
))
3116 pp_string (pp
, "__transaction_relaxed");
3118 pp_string (pp
, "__transaction_atomic");
3119 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3121 newline_and_indent (pp
, spc
);
3123 newline_and_indent (pp
, spc
+ 2);
3124 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3125 spc
+ 2, flags
, false);
3126 newline_and_indent (pp
, spc
);
3127 pp_right_brace (pp
);
3132 case REDUC_MAX_EXPR
:
3133 pp_string (pp
, " REDUC_MAX_EXPR < ");
3134 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3135 pp_string (pp
, " > ");
3138 case REDUC_MIN_EXPR
:
3139 pp_string (pp
, " REDUC_MIN_EXPR < ");
3140 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3141 pp_string (pp
, " > ");
3144 case REDUC_PLUS_EXPR
:
3145 pp_string (pp
, " REDUC_PLUS_EXPR < ");
3146 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3147 pp_string (pp
, " > ");
3150 case VEC_WIDEN_MULT_HI_EXPR
:
3151 case VEC_WIDEN_MULT_LO_EXPR
:
3152 case VEC_WIDEN_MULT_EVEN_EXPR
:
3153 case VEC_WIDEN_MULT_ODD_EXPR
:
3154 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3155 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3157 for (str
= get_tree_code_name (code
); *str
; str
++)
3158 pp_character (pp
, TOUPPER (*str
));
3159 pp_string (pp
, " < ");
3160 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3161 pp_string (pp
, ", ");
3162 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3163 pp_string (pp
, " > ");
3166 case VEC_UNPACK_HI_EXPR
:
3167 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3168 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3169 pp_string (pp
, " > ");
3172 case VEC_UNPACK_LO_EXPR
:
3173 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3174 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3175 pp_string (pp
, " > ");
3178 case VEC_UNPACK_FLOAT_HI_EXPR
:
3179 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3180 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3181 pp_string (pp
, " > ");
3184 case VEC_UNPACK_FLOAT_LO_EXPR
:
3185 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3186 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3187 pp_string (pp
, " > ");
3190 case VEC_PACK_TRUNC_EXPR
:
3191 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3192 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3193 pp_string (pp
, ", ");
3194 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3195 pp_string (pp
, " > ");
3198 case VEC_PACK_SAT_EXPR
:
3199 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3200 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3201 pp_string (pp
, ", ");
3202 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3203 pp_string (pp
, " > ");
3206 case VEC_PACK_FIX_TRUNC_EXPR
:
3207 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3208 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3209 pp_string (pp
, ", ");
3210 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3211 pp_string (pp
, " > ");
3215 dump_block_node (pp
, node
, spc
, flags
);
3218 case CILK_SPAWN_STMT
:
3219 pp_string (pp
, "_Cilk_spawn ");
3220 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3223 case CILK_SYNC_STMT
:
3224 pp_string (pp
, "_Cilk_sync");
3231 if (is_stmt
&& is_expr
)
3237 /* Print the declaration of a variable. */
3240 print_declaration (pretty_printer
*pp
, tree t
, int spc
, int flags
)
3244 if (TREE_CODE(t
) == NAMELIST_DECL
)
3246 pp_string(pp
, "namelist ");
3247 dump_decl_name (pp
, t
, flags
);
3252 if (TREE_CODE (t
) == TYPE_DECL
)
3253 pp_string (pp
, "typedef ");
3255 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3256 pp_string (pp
, "register ");
3258 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3259 pp_string (pp
, "extern ");
3260 else if (TREE_STATIC (t
))
3261 pp_string (pp
, "static ");
3263 /* Print the type and name. */
3264 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3268 /* Print array's type. */
3269 tmp
= TREE_TYPE (t
);
3270 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3271 tmp
= TREE_TYPE (tmp
);
3272 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3274 /* Print variable's name. */
3276 dump_generic_node (pp
, t
, spc
, flags
, false);
3278 /* Print the dimensions. */
3279 tmp
= TREE_TYPE (t
);
3280 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3282 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3283 tmp
= TREE_TYPE (tmp
);
3286 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3288 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3290 dump_decl_name (pp
, t
, flags
);
3291 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3295 /* Print type declaration. */
3296 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3298 /* Print variable's name. */
3300 dump_generic_node (pp
, t
, spc
, flags
, false);
3303 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
3305 pp_string (pp
, " __asm__ ");
3307 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3308 pp_right_paren (pp
);
3311 /* The initial value of a function serves to determine whether the function
3312 is declared or defined. So the following does not apply to function
3314 if (TREE_CODE (t
) != FUNCTION_DECL
)
3316 /* Print the initial value. */
3317 if (DECL_INITIAL (t
))
3322 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3326 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3328 pp_string (pp
, " [value-expr: ");
3329 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3330 pp_right_bracket (pp
);
3337 /* Prints a structure: name, fields, and methods.
3338 FIXME: Still incomplete. */
3341 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
, int flags
)
3343 /* Print the name of the structure. */
3344 if (TYPE_NAME (node
))
3347 if (TREE_CODE (node
) == RECORD_TYPE
)
3348 pp_string (pp
, "struct ");
3349 else if ((TREE_CODE (node
) == UNION_TYPE
3350 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3351 pp_string (pp
, "union ");
3353 dump_generic_node (pp
, TYPE_NAME (node
), spc
, 0, false);
3356 /* Print the contents of the structure. */
3362 /* Print the fields of the structure. */
3365 tmp
= TYPE_FIELDS (node
);
3368 /* Avoid to print recursively the structure. */
3369 /* FIXME : Not implemented correctly...,
3370 what about the case when we have a cycle in the contain graph? ...
3371 Maybe this could be solved by looking at the scope in which the
3372 structure was declared. */
3373 if (TREE_TYPE (tmp
) != node
3374 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3375 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3377 print_declaration (pp
, tmp
, spc
+2, flags
);
3380 tmp
= DECL_CHAIN (tmp
);
3384 pp_right_brace (pp
);
3387 /* Return the priority of the operator CODE.
3389 From lowest to highest precedence with either left-to-right (L-R)
3390 or right-to-left (R-L) associativity]:
3393 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3405 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3406 15 [L-R] fn() [] -> .
3408 unary +, - and * have higher precedence than the corresponding binary
3412 op_code_prio (enum tree_code code
)
3429 case TRUTH_ORIF_EXPR
:
3432 case TRUTH_AND_EXPR
:
3433 case TRUTH_ANDIF_EXPR
:
3440 case TRUTH_XOR_EXPR
:
3457 case UNORDERED_EXPR
:
3468 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3469 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3470 case WIDEN_LSHIFT_EXPR
:
3473 case WIDEN_SUM_EXPR
:
3475 case POINTER_PLUS_EXPR
:
3479 case VEC_WIDEN_MULT_HI_EXPR
:
3480 case VEC_WIDEN_MULT_LO_EXPR
:
3481 case WIDEN_MULT_EXPR
:
3483 case WIDEN_MULT_PLUS_EXPR
:
3484 case WIDEN_MULT_MINUS_EXPR
:
3486 case MULT_HIGHPART_EXPR
:
3487 case TRUNC_DIV_EXPR
:
3489 case FLOOR_DIV_EXPR
:
3490 case ROUND_DIV_EXPR
:
3492 case EXACT_DIV_EXPR
:
3493 case TRUNC_MOD_EXPR
:
3495 case FLOOR_MOD_EXPR
:
3496 case ROUND_MOD_EXPR
:
3500 case TRUTH_NOT_EXPR
:
3502 case POSTINCREMENT_EXPR
:
3503 case POSTDECREMENT_EXPR
:
3504 case PREINCREMENT_EXPR
:
3505 case PREDECREMENT_EXPR
:
3511 case FIX_TRUNC_EXPR
:
3517 case ARRAY_RANGE_REF
:
3521 /* Special expressions. */
3527 case REDUC_MAX_EXPR
:
3528 case REDUC_MIN_EXPR
:
3529 case REDUC_PLUS_EXPR
:
3530 case VEC_UNPACK_HI_EXPR
:
3531 case VEC_UNPACK_LO_EXPR
:
3532 case VEC_UNPACK_FLOAT_HI_EXPR
:
3533 case VEC_UNPACK_FLOAT_LO_EXPR
:
3534 case VEC_PACK_TRUNC_EXPR
:
3535 case VEC_PACK_SAT_EXPR
:
3539 /* Return an arbitrarily high precedence to avoid surrounding single
3540 VAR_DECLs in ()s. */
3545 /* Return the priority of the operator OP. */
3548 op_prio (const_tree op
)
3550 enum tree_code code
;
3555 code
= TREE_CODE (op
);
3556 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3557 return op_prio (TREE_OPERAND (op
, 0));
3559 return op_code_prio (code
);
3562 /* Return the symbol associated with operator CODE. */
3565 op_symbol_code (enum tree_code code
)
3573 case TRUTH_ORIF_EXPR
:
3576 case TRUTH_AND_EXPR
:
3577 case TRUTH_ANDIF_EXPR
:
3583 case TRUTH_XOR_EXPR
:
3593 case UNORDERED_EXPR
:
3639 case WIDEN_LSHIFT_EXPR
:
3642 case POINTER_PLUS_EXPR
:
3648 case REDUC_PLUS_EXPR
:
3651 case WIDEN_SUM_EXPR
:
3654 case WIDEN_MULT_EXPR
:
3657 case MULT_HIGHPART_EXPR
:
3667 case TRUTH_NOT_EXPR
:
3674 case TRUNC_DIV_EXPR
:
3681 case FLOOR_DIV_EXPR
:
3684 case ROUND_DIV_EXPR
:
3687 case EXACT_DIV_EXPR
:
3690 case TRUNC_MOD_EXPR
:
3696 case FLOOR_MOD_EXPR
:
3699 case ROUND_MOD_EXPR
:
3702 case PREDECREMENT_EXPR
:
3705 case PREINCREMENT_EXPR
:
3708 case POSTDECREMENT_EXPR
:
3711 case POSTINCREMENT_EXPR
:
3721 return "<<< ??? >>>";
3725 /* Return the symbol associated with operator OP. */
3728 op_symbol (const_tree op
)
3730 return op_symbol_code (TREE_CODE (op
));
3733 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3734 the gimple_call_fn of a GIMPLE_CALL. */
3737 print_call_name (pretty_printer
*pp
, tree node
, int flags
)
3741 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3742 op0
= TREE_OPERAND (op0
, 0);
3745 switch (TREE_CODE (op0
))
3750 dump_function_name (pp
, op0
, flags
);
3756 op0
= TREE_OPERAND (op0
, 0);
3761 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3762 pp_string (pp
, ") ? ");
3763 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3764 pp_string (pp
, " : ");
3765 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3769 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3770 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
3772 dump_generic_node (pp
, op0
, 0, flags
, false);
3776 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3778 op0
= TREE_OPERAND (op0
, 0);
3785 dump_generic_node (pp
, op0
, 0, flags
, false);
3793 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3796 pretty_print_string (pretty_printer
*pp
, const char *str
)
3806 pp_string (pp
, "\\b");
3810 pp_string (pp
, "\\f");
3814 pp_string (pp
, "\\n");
3818 pp_string (pp
, "\\r");
3822 pp_string (pp
, "\\t");
3826 pp_string (pp
, "\\v");
3830 pp_string (pp
, "\\\\");
3834 pp_string (pp
, "\\\"");
3838 pp_string (pp
, "\\'");
3841 /* No need to handle \0; the loop terminates on \0. */
3844 pp_string (pp
, "\\1");
3848 pp_string (pp
, "\\2");
3852 pp_string (pp
, "\\3");
3856 pp_string (pp
, "\\4");
3860 pp_string (pp
, "\\5");
3864 pp_string (pp
, "\\6");
3868 pp_string (pp
, "\\7");
3872 pp_character (pp
, str
[0]);
3880 maybe_init_pretty_print (FILE *file
)
3884 tree_pp
= new pretty_printer ();
3885 pp_needs_newline (tree_pp
) = true;
3886 pp_translate_identifiers (tree_pp
) = false;
3889 tree_pp
->buffer
->stream
= file
;
3893 newline_and_indent (pretty_printer
*pp
, int spc
)
3899 /* Handle a %K format for TEXT. Separate from default_tree_printer so
3900 it can also be used in front ends.
3901 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3905 percent_K_format (text_info
*text
)
3907 tree t
= va_arg (*text
->args_ptr
, tree
), block
;
3908 text
->set_location (0, EXPR_LOCATION (t
), true);
3909 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3910 block
= TREE_BLOCK (t
);
3911 *pp_ti_abstract_origin (text
) = NULL
;
3915 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3916 representing the outermost block of an inlined function.
3917 So walk the BLOCK tree until we hit such a scope. */
3919 && TREE_CODE (block
) == BLOCK
)
3921 if (inlined_function_outer_scope_p (block
))
3923 *pp_ti_abstract_origin (text
) = block
;
3926 block
= BLOCK_SUPERCONTEXT (block
);
3932 && TREE_CODE (block
) == BLOCK
3933 && BLOCK_ABSTRACT_ORIGIN (block
))
3935 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3937 while (TREE_CODE (ao
) == BLOCK
3938 && BLOCK_ABSTRACT_ORIGIN (ao
)
3939 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3940 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3942 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3944 *pp_ti_abstract_origin (text
) = block
;
3947 block
= BLOCK_SUPERCONTEXT (block
);
3951 /* Print the identifier ID to PRETTY-PRINTER. */
3954 pp_tree_identifier (pretty_printer
*pp
, tree id
)
3956 if (pp_translate_identifiers (pp
))
3958 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
3959 pp_append_text (pp
, text
, text
+ strlen (text
));
3962 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
3963 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
3966 /* A helper function that is used to dump function information before the
3970 dump_function_header (FILE *dump_file
, tree fdecl
, int flags
)
3972 const char *dname
, *aname
;
3973 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
3974 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
3976 dname
= lang_hooks
.decl_printable_name (fdecl
, 2);
3978 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
3979 aname
= (IDENTIFIER_POINTER
3980 (DECL_ASSEMBLER_NAME (fdecl
)));
3982 aname
= "<unset-asm-name>";
3984 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
3985 dname
, aname
, fun
->funcdef_no
);
3986 if (!(flags
& TDF_NOUID
))
3987 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
3990 fprintf (dump_file
, ", cgraph_uid=%d", node
->uid
);
3991 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
3992 node
->frequency
== NODE_FREQUENCY_HOT
3994 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
3995 ? " (unlikely executed)"
3996 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
3997 ? " (executed once)"
4001 fprintf (dump_file
, ")\n\n");
4004 /* Dump double_int D to pretty_printer PP. UNS is true
4005 if D is unsigned and false otherwise. */
4007 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4010 pp_wide_integer (pp
, d
.low
);
4011 else if (d
.fits_uhwi ())
4012 pp_unsigned_wide_integer (pp
, d
.low
);
4015 unsigned HOST_WIDE_INT low
= d
.low
;
4016 HOST_WIDE_INT high
= d
.high
;
4017 if (!uns
&& d
.is_negative ())
4020 high
= ~high
+ !low
;
4023 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4025 sprintf (pp_buffer (pp
)->digit_buffer
,
4026 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4027 (unsigned HOST_WIDE_INT
) high
, low
);
4028 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);