1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2019 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 #include "fold-const.h"
39 /* Disable warnings about quoting issues in the pp_xxx calls below
40 that (intentionally) don't follow GCC diagnostic conventions. */
42 # pragma GCC diagnostic push
43 # pragma GCC diagnostic ignored "-Wformat-diag"
46 /* Local functions, macros and variables. */
47 static const char *op_symbol (const_tree
);
48 static void pretty_print_string (pretty_printer
*, const char*, unsigned);
49 static void newline_and_indent (pretty_printer
*, int);
50 static void maybe_init_pretty_print (FILE *);
51 static void print_struct_decl (pretty_printer
*, const_tree
, int, dump_flags_t
);
52 static void do_niy (pretty_printer
*, const_tree
, dump_flags_t
);
54 #define INDENT(SPACE) do { \
55 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
57 #define NIY do_niy (pp, node, flags)
59 static pretty_printer
*tree_pp
;
61 /* Try to print something for an unknown tree code. */
64 do_niy (pretty_printer
*pp
, const_tree node
, dump_flags_t flags
)
68 pp_string (pp
, "<<< Unknown tree: ");
69 pp_string (pp
, get_tree_code_name (TREE_CODE (node
)));
73 len
= TREE_OPERAND_LENGTH (node
);
74 for (i
= 0; i
< len
; ++i
)
76 newline_and_indent (pp
, 2);
77 dump_generic_node (pp
, TREE_OPERAND (node
, i
), 2, flags
, false);
81 pp_string (pp
, " >>>");
84 /* Debugging function to print out a generic expression. */
87 debug_generic_expr (tree t
)
89 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
90 fprintf (stderr
, "\n");
93 /* Debugging function to print out a generic statement. */
96 debug_generic_stmt (tree t
)
98 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
99 fprintf (stderr
, "\n");
102 /* Debugging function to print out a chain of trees . */
105 debug_tree_chain (tree t
)
111 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
112 fprintf (stderr
, " ");
116 fprintf (stderr
, "... [cycled back to ");
117 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
118 fprintf (stderr
, "]");
122 fprintf (stderr
, "\n");
125 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
127 print_generic_decl (FILE *file
, tree decl
, dump_flags_t flags
)
129 maybe_init_pretty_print (file
);
130 print_declaration (tree_pp
, decl
, 2, flags
);
131 pp_write_text_to_stream (tree_pp
);
134 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
135 to show in the dump. See TDF_* in dumpfile.h. */
138 print_generic_stmt (FILE *file
, tree t
, dump_flags_t flags
)
140 maybe_init_pretty_print (file
);
141 dump_generic_node (tree_pp
, t
, 0, flags
, true);
142 pp_newline_and_flush (tree_pp
);
145 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
146 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
150 print_generic_stmt_indented (FILE *file
, tree t
, dump_flags_t flags
, int indent
)
154 maybe_init_pretty_print (file
);
156 for (i
= 0; i
< indent
; i
++)
158 dump_generic_node (tree_pp
, t
, indent
, flags
, true);
159 pp_newline_and_flush (tree_pp
);
162 /* Print a single expression T on file FILE. FLAGS specifies details to show
163 in the dump. See TDF_* in dumpfile.h. */
166 print_generic_expr (FILE *file
, tree t
, dump_flags_t flags
)
168 maybe_init_pretty_print (file
);
169 dump_generic_node (tree_pp
, t
, 0, flags
, false);
173 /* Print a single expression T to string, and return it. */
176 print_generic_expr_to_str (tree t
)
179 dump_generic_node (&pp
, t
, 0, TDF_VOPS
|TDF_MEMSYMS
, false);
180 return xstrdup (pp_formatted_text (&pp
));
183 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
184 in it are replaced with Dxxxx, as long as they are at the start or
185 preceded by $ and at the end or followed by $. See make_fancy_name
189 dump_fancy_name (pretty_printer
*pp
, tree name
)
192 int length
= IDENTIFIER_LENGTH (name
);
193 const char *n
= IDENTIFIER_POINTER (name
);
200 && (n
== IDENTIFIER_POINTER (name
) || n
[-1] == '$'))
203 while (ISDIGIT (n
[l
]))
205 if (n
[l
] == '\0' || n
[l
] == '$')
218 pp_tree_identifier (pp
, name
);
222 char *str
= XNEWVEC (char, length
+ 1);
225 q
= n
= IDENTIFIER_POINTER (name
);
232 && (q
== IDENTIFIER_POINTER (name
) || q
[-1] == '$'))
235 while (ISDIGIT (q
[l
]))
237 if (q
[l
] == '\0' || q
[l
] == '$')
239 memcpy (p
, n
, q
- n
);
240 memcpy (p
+ (q
- n
), "Dxxxx", 5);
250 memcpy (p
, n
, IDENTIFIER_LENGTH (name
) - (n
- IDENTIFIER_POINTER (name
)));
252 if (pp_translate_identifiers (pp
))
254 const char *text
= identifier_to_locale (str
);
255 pp_append_text (pp
, text
, text
+ strlen (text
));
258 pp_append_text (pp
, str
, str
+ length
);
262 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
266 dump_decl_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
268 tree name
= DECL_NAME (node
);
271 if ((flags
& TDF_ASMNAME
)
272 && HAS_DECL_ASSEMBLER_NAME_P (node
)
273 && DECL_ASSEMBLER_NAME_SET_P (node
))
274 pp_tree_identifier (pp
, DECL_ASSEMBLER_NAME_RAW (node
));
275 /* For -fcompare-debug don't dump DECL_NAMELESS names at all,
276 -g might have created more fancy names and their indexes
277 could get out of sync. Usually those should be DECL_IGNORED_P
278 too, SRA can create even non-DECL_IGNORED_P DECL_NAMELESS fancy
279 names, let's hope those never get out of sync after doing the
280 dump_fancy_name sanitization. */
281 else if ((flags
& TDF_COMPARE_DEBUG
)
282 && DECL_NAMELESS (node
)
283 && DECL_IGNORED_P (node
))
285 /* For DECL_NAMELESS names look for embedded uids in the
286 names and sanitize them for TDF_NOUID. */
287 else if ((flags
& TDF_NOUID
) && DECL_NAMELESS (node
))
288 dump_fancy_name (pp
, name
);
290 pp_tree_identifier (pp
, name
);
292 char uid_sep
= (flags
& TDF_GIMPLE
) ? '_' : '.';
293 if ((flags
& TDF_UID
) || name
== NULL_TREE
)
295 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
296 pp_printf (pp
, "L%c%d", uid_sep
, (int) LABEL_DECL_UID (node
));
297 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
299 if (flags
& TDF_NOUID
)
300 pp_string (pp
, "D#xxxx");
302 pp_printf (pp
, "D#%i", DEBUG_TEMP_UID (node
));
306 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
307 if (flags
& TDF_NOUID
)
308 pp_printf (pp
, "%c.xxxx", c
);
310 pp_printf (pp
, "%c%c%u", c
, uid_sep
, DECL_UID (node
));
313 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
315 if (flags
& TDF_NOUID
)
316 pp_printf (pp
, "ptD.xxxx");
318 pp_printf (pp
, "ptD.%u", DECL_PT_UID (node
));
322 /* Like the above, but used for pretty printing function calls. */
325 dump_function_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
327 if (CONVERT_EXPR_P (node
))
328 node
= TREE_OPERAND (node
, 0);
329 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
330 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
332 dump_decl_name (pp
, node
, flags
);
335 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
336 FLAGS are as in dump_generic_node. */
339 dump_function_declaration (pretty_printer
*pp
, tree node
,
340 int spc
, dump_flags_t flags
)
342 bool wrote_arg
= false;
348 /* Print the argument types. */
349 arg
= TYPE_ARG_TYPES (node
);
350 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
358 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
359 arg
= TREE_CHAIN (arg
);
362 /* Drop the trailing void_type_node if we had any previous argument. */
363 if (arg
== void_list_node
&& !wrote_arg
)
364 pp_string (pp
, "void");
365 /* Properly dump vararg function types. */
366 else if (!arg
&& wrote_arg
)
367 pp_string (pp
, ", ...");
368 /* Avoid printing any arg for unprototyped functions. */
373 /* Dump the domain associated with an array. */
376 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, dump_flags_t flags
)
378 pp_left_bracket (pp
);
381 tree min
= TYPE_MIN_VALUE (domain
);
382 tree max
= TYPE_MAX_VALUE (domain
);
385 && integer_zerop (min
)
386 && tree_fits_shwi_p (max
))
387 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
391 dump_generic_node (pp
, min
, spc
, flags
, false);
394 dump_generic_node (pp
, max
, spc
, flags
, false);
398 pp_string (pp
, "<unknown>");
399 pp_right_bracket (pp
);
403 /* Dump OpenMP iterators ITER. */
406 dump_omp_iterators (pretty_printer
*pp
, tree iter
, int spc
, dump_flags_t flags
)
408 pp_string (pp
, "iterator(");
409 for (tree it
= iter
; it
; it
= TREE_CHAIN (it
))
412 pp_string (pp
, ", ");
413 dump_generic_node (pp
, TREE_TYPE (TREE_VEC_ELT (it
, 0)), spc
, flags
,
416 dump_generic_node (pp
, TREE_VEC_ELT (it
, 0), spc
, flags
, false);
418 dump_generic_node (pp
, TREE_VEC_ELT (it
, 1), spc
, flags
, false);
420 dump_generic_node (pp
, TREE_VEC_ELT (it
, 2), spc
, flags
, false);
422 dump_generic_node (pp
, TREE_VEC_ELT (it
, 3), spc
, flags
, false);
428 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
429 dump_generic_node. */
432 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
436 switch (OMP_CLAUSE_CODE (clause
))
438 case OMP_CLAUSE_PRIVATE
:
441 case OMP_CLAUSE_SHARED
:
444 case OMP_CLAUSE_FIRSTPRIVATE
:
445 name
= "firstprivate";
447 case OMP_CLAUSE_LASTPRIVATE
:
448 name
= "lastprivate";
449 if (!OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clause
))
451 pp_string (pp
, "lastprivate(conditional:");
452 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
456 case OMP_CLAUSE_COPYIN
:
459 case OMP_CLAUSE_COPYPRIVATE
:
460 name
= "copyprivate";
462 case OMP_CLAUSE_UNIFORM
:
465 case OMP_CLAUSE_USE_DEVICE_PTR
:
466 name
= "use_device_ptr";
468 case OMP_CLAUSE_USE_DEVICE_ADDR
:
469 name
= "use_device_addr";
471 case OMP_CLAUSE_IS_DEVICE_PTR
:
472 name
= "is_device_ptr";
474 case OMP_CLAUSE_INCLUSIVE
:
477 case OMP_CLAUSE_EXCLUSIVE
:
480 case OMP_CLAUSE__LOOPTEMP_
:
483 case OMP_CLAUSE__REDUCTEMP_
:
484 name
= "_reductemp_";
486 case OMP_CLAUSE__CONDTEMP_
:
489 case OMP_CLAUSE__SCANTEMP_
:
492 case OMP_CLAUSE_TO_DECLARE
:
495 case OMP_CLAUSE_LINK
:
498 case OMP_CLAUSE_NONTEMPORAL
:
499 name
= "nontemporal";
502 pp_string (pp
, name
);
504 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
509 case OMP_CLAUSE_TASK_REDUCTION
:
510 case OMP_CLAUSE_IN_REDUCTION
:
511 pp_string (pp
, OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_IN_REDUCTION
514 case OMP_CLAUSE_REDUCTION
:
515 pp_string (pp
, "reduction(");
516 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_REDUCTION
)
518 if (OMP_CLAUSE_REDUCTION_TASK (clause
))
519 pp_string (pp
, "task,");
520 else if (OMP_CLAUSE_REDUCTION_INSCAN (clause
))
521 pp_string (pp
, "inscan,");
523 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
526 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
529 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
535 pp_string (pp
, "if(");
536 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
538 case ERROR_MARK
: break;
539 case VOID_CST
: pp_string (pp
, "cancel:"); break;
540 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
541 case OMP_SIMD
: pp_string (pp
, "simd:"); break;
542 case OMP_TASK
: pp_string (pp
, "task:"); break;
543 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
544 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
545 case OMP_TARGET
: pp_string (pp
, "target:"); break;
546 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
547 case OMP_TARGET_ENTER_DATA
:
548 pp_string (pp
, "target enter data:"); break;
549 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
550 default: gcc_unreachable ();
552 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
557 case OMP_CLAUSE_NUM_THREADS
:
558 pp_string (pp
, "num_threads(");
559 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
564 case OMP_CLAUSE_NOWAIT
:
565 pp_string (pp
, "nowait");
567 case OMP_CLAUSE_ORDERED
:
568 pp_string (pp
, "ordered");
569 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
572 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
578 case OMP_CLAUSE_DEFAULT
:
579 pp_string (pp
, "default(");
580 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
582 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
584 case OMP_CLAUSE_DEFAULT_SHARED
:
585 pp_string (pp
, "shared");
587 case OMP_CLAUSE_DEFAULT_NONE
:
588 pp_string (pp
, "none");
590 case OMP_CLAUSE_DEFAULT_PRIVATE
:
591 pp_string (pp
, "private");
593 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
594 pp_string (pp
, "firstprivate");
596 case OMP_CLAUSE_DEFAULT_PRESENT
:
597 pp_string (pp
, "present");
605 case OMP_CLAUSE_SCHEDULE
:
606 pp_string (pp
, "schedule(");
607 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
608 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
609 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
611 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
612 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
613 pp_string (pp
, "monotonic");
615 pp_string (pp
, "nonmonotonic");
616 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
621 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
622 pp_string (pp
, "simd:");
624 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
626 case OMP_CLAUSE_SCHEDULE_STATIC
:
627 pp_string (pp
, "static");
629 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
630 pp_string (pp
, "dynamic");
632 case OMP_CLAUSE_SCHEDULE_GUIDED
:
633 pp_string (pp
, "guided");
635 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
636 pp_string (pp
, "runtime");
638 case OMP_CLAUSE_SCHEDULE_AUTO
:
639 pp_string (pp
, "auto");
644 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
647 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
653 case OMP_CLAUSE_UNTIED
:
654 pp_string (pp
, "untied");
657 case OMP_CLAUSE_COLLAPSE
:
658 pp_string (pp
, "collapse(");
659 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
664 case OMP_CLAUSE_FINAL
:
665 pp_string (pp
, "final(");
666 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
671 case OMP_CLAUSE_MERGEABLE
:
672 pp_string (pp
, "mergeable");
675 case OMP_CLAUSE_LINEAR
:
676 pp_string (pp
, "linear(");
677 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
679 case OMP_CLAUSE_LINEAR_DEFAULT
:
681 case OMP_CLAUSE_LINEAR_REF
:
682 pp_string (pp
, "ref(");
684 case OMP_CLAUSE_LINEAR_VAL
:
685 pp_string (pp
, "val(");
687 case OMP_CLAUSE_LINEAR_UVAL
:
688 pp_string (pp
, "uval(");
693 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
695 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
698 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
703 case OMP_CLAUSE_ALIGNED
:
704 pp_string (pp
, "aligned(");
705 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
707 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
710 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
716 case OMP_CLAUSE_DEPEND
:
717 pp_string (pp
, "depend(");
718 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
720 case OMP_CLAUSE_DEPEND_DEPOBJ
:
723 case OMP_CLAUSE_DEPEND_IN
:
726 case OMP_CLAUSE_DEPEND_OUT
:
729 case OMP_CLAUSE_DEPEND_INOUT
:
732 case OMP_CLAUSE_DEPEND_MUTEXINOUTSET
:
733 name
= "mutexinoutset";
735 case OMP_CLAUSE_DEPEND_SOURCE
:
736 pp_string (pp
, "source)");
738 case OMP_CLAUSE_DEPEND_LAST
:
739 name
= "__internal__";
741 case OMP_CLAUSE_DEPEND_SINK
:
742 pp_string (pp
, "sink:");
743 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
744 if (TREE_CODE (t
) == TREE_LIST
)
746 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
747 if (TREE_PURPOSE (t
) != integer_zero_node
)
749 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
753 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
767 tree t
= OMP_CLAUSE_DECL (clause
);
768 if (TREE_CODE (t
) == TREE_LIST
770 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
772 dump_omp_iterators (pp
, TREE_PURPOSE (t
), spc
, flags
);
776 pp_string (pp
, name
);
778 dump_generic_node (pp
, t
, spc
, flags
, false);
784 pp_string (pp
, "map(");
785 switch (OMP_CLAUSE_MAP_KIND (clause
))
788 case GOMP_MAP_POINTER
:
789 pp_string (pp
, "alloc");
792 case GOMP_MAP_TO_PSET
:
793 pp_string (pp
, "to");
796 pp_string (pp
, "from");
798 case GOMP_MAP_TOFROM
:
799 pp_string (pp
, "tofrom");
801 case GOMP_MAP_FORCE_ALLOC
:
802 pp_string (pp
, "force_alloc");
804 case GOMP_MAP_FORCE_TO
:
805 pp_string (pp
, "force_to");
807 case GOMP_MAP_FORCE_FROM
:
808 pp_string (pp
, "force_from");
810 case GOMP_MAP_FORCE_TOFROM
:
811 pp_string (pp
, "force_tofrom");
813 case GOMP_MAP_FORCE_PRESENT
:
814 pp_string (pp
, "force_present");
816 case GOMP_MAP_DELETE
:
817 pp_string (pp
, "delete");
819 case GOMP_MAP_FORCE_DEVICEPTR
:
820 pp_string (pp
, "force_deviceptr");
822 case GOMP_MAP_ALWAYS_TO
:
823 pp_string (pp
, "always,to");
825 case GOMP_MAP_ALWAYS_FROM
:
826 pp_string (pp
, "always,from");
828 case GOMP_MAP_ALWAYS_TOFROM
:
829 pp_string (pp
, "always,tofrom");
831 case GOMP_MAP_RELEASE
:
832 pp_string (pp
, "release");
834 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
835 pp_string (pp
, "firstprivate");
837 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
838 pp_string (pp
, "firstprivate ref");
840 case GOMP_MAP_STRUCT
:
841 pp_string (pp
, "struct");
843 case GOMP_MAP_ALWAYS_POINTER
:
844 pp_string (pp
, "always_pointer");
846 case GOMP_MAP_DEVICE_RESIDENT
:
847 pp_string (pp
, "device_resident");
850 pp_string (pp
, "link");
856 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
859 if (OMP_CLAUSE_SIZE (clause
))
861 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
862 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
864 case GOMP_MAP_POINTER
:
865 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
866 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
867 case GOMP_MAP_ALWAYS_POINTER
:
868 pp_string (pp
, " [pointer assign, bias: ");
870 case GOMP_MAP_TO_PSET
:
871 pp_string (pp
, " [pointer set, len: ");
874 pp_string (pp
, " [len: ");
877 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
879 pp_right_bracket (pp
);
884 case OMP_CLAUSE_FROM
:
885 pp_string (pp
, "from(");
886 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
888 goto print_clause_size
;
891 pp_string (pp
, "to(");
892 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
894 goto print_clause_size
;
896 case OMP_CLAUSE__CACHE_
:
898 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
900 goto print_clause_size
;
902 case OMP_CLAUSE_NUM_TEAMS
:
903 pp_string (pp
, "num_teams(");
904 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
909 case OMP_CLAUSE_THREAD_LIMIT
:
910 pp_string (pp
, "thread_limit(");
911 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
916 case OMP_CLAUSE_DEVICE
:
917 pp_string (pp
, "device(");
918 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
923 case OMP_CLAUSE_DIST_SCHEDULE
:
924 pp_string (pp
, "dist_schedule(static");
925 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
928 dump_generic_node (pp
,
929 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
935 case OMP_CLAUSE_PROC_BIND
:
936 pp_string (pp
, "proc_bind(");
937 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
939 case OMP_CLAUSE_PROC_BIND_MASTER
:
940 pp_string (pp
, "master");
942 case OMP_CLAUSE_PROC_BIND_CLOSE
:
943 pp_string (pp
, "close");
945 case OMP_CLAUSE_PROC_BIND_SPREAD
:
946 pp_string (pp
, "spread");
954 case OMP_CLAUSE_SAFELEN
:
955 pp_string (pp
, "safelen(");
956 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
961 case OMP_CLAUSE_SIMDLEN
:
962 pp_string (pp
, "simdlen(");
963 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
968 case OMP_CLAUSE_PRIORITY
:
969 pp_string (pp
, "priority(");
970 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
975 case OMP_CLAUSE_GRAINSIZE
:
976 pp_string (pp
, "grainsize(");
977 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
982 case OMP_CLAUSE_NUM_TASKS
:
983 pp_string (pp
, "num_tasks(");
984 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
989 case OMP_CLAUSE_HINT
:
990 pp_string (pp
, "hint(");
991 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
996 case OMP_CLAUSE_DEFAULTMAP
:
997 pp_string (pp
, "defaultmap(");
998 switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (clause
))
1000 case OMP_CLAUSE_DEFAULTMAP_ALLOC
:
1001 pp_string (pp
, "alloc");
1003 case OMP_CLAUSE_DEFAULTMAP_TO
:
1004 pp_string (pp
, "to");
1006 case OMP_CLAUSE_DEFAULTMAP_FROM
:
1007 pp_string (pp
, "from");
1009 case OMP_CLAUSE_DEFAULTMAP_TOFROM
:
1010 pp_string (pp
, "tofrom");
1012 case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE
:
1013 pp_string (pp
, "firstprivate");
1015 case OMP_CLAUSE_DEFAULTMAP_NONE
:
1016 pp_string (pp
, "none");
1018 case OMP_CLAUSE_DEFAULTMAP_DEFAULT
:
1019 pp_string (pp
, "default");
1024 switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (clause
))
1026 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED
:
1028 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR
:
1029 pp_string (pp
, ":scalar");
1031 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE
:
1032 pp_string (pp
, ":aggregate");
1034 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE
:
1035 pp_string (pp
, ":allocatable");
1037 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER
:
1038 pp_string (pp
, ":pointer");
1043 pp_right_paren (pp
);
1046 case OMP_CLAUSE_ORDER
:
1047 pp_string (pp
, "order(concurrent)");
1050 case OMP_CLAUSE_BIND
:
1051 pp_string (pp
, "bind(");
1052 switch (OMP_CLAUSE_BIND_KIND (clause
))
1054 case OMP_CLAUSE_BIND_TEAMS
:
1055 pp_string (pp
, "teams");
1057 case OMP_CLAUSE_BIND_PARALLEL
:
1058 pp_string (pp
, "parallel");
1060 case OMP_CLAUSE_BIND_THREAD
:
1061 pp_string (pp
, "thread");
1066 pp_right_paren (pp
);
1069 case OMP_CLAUSE__SIMDUID_
:
1070 pp_string (pp
, "_simduid_(");
1071 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
1073 pp_right_paren (pp
);
1076 case OMP_CLAUSE__SIMT_
:
1077 pp_string (pp
, "_simt_");
1080 case OMP_CLAUSE_GANG
:
1081 pp_string (pp
, "gang");
1082 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
1084 pp_string (pp
, "(num: ");
1085 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
1088 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
1090 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
1094 pp_string (pp
, "static:");
1095 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
1096 == integer_minus_one_node
)
1097 pp_character (pp
, '*');
1099 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
1102 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
1103 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
1104 pp_right_paren (pp
);
1107 case OMP_CLAUSE_ASYNC
:
1108 pp_string (pp
, "async");
1109 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
1111 pp_character(pp
, '(');
1112 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
1114 pp_character(pp
, ')');
1118 case OMP_CLAUSE_AUTO
:
1119 case OMP_CLAUSE_SEQ
:
1120 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
1123 case OMP_CLAUSE_WAIT
:
1124 pp_string (pp
, "wait(");
1125 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
1127 pp_character(pp
, ')');
1130 case OMP_CLAUSE_WORKER
:
1131 pp_string (pp
, "worker");
1132 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
1135 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
1137 pp_right_paren (pp
);
1141 case OMP_CLAUSE_VECTOR
:
1142 pp_string (pp
, "vector");
1143 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
1146 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
1148 pp_right_paren (pp
);
1152 case OMP_CLAUSE_NUM_GANGS
:
1153 pp_string (pp
, "num_gangs(");
1154 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
1156 pp_character (pp
, ')');
1159 case OMP_CLAUSE_NUM_WORKERS
:
1160 pp_string (pp
, "num_workers(");
1161 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
1163 pp_character (pp
, ')');
1166 case OMP_CLAUSE_VECTOR_LENGTH
:
1167 pp_string (pp
, "vector_length(");
1168 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
1170 pp_character (pp
, ')');
1173 case OMP_CLAUSE_INBRANCH
:
1174 pp_string (pp
, "inbranch");
1176 case OMP_CLAUSE_NOTINBRANCH
:
1177 pp_string (pp
, "notinbranch");
1179 case OMP_CLAUSE_FOR
:
1180 pp_string (pp
, "for");
1182 case OMP_CLAUSE_PARALLEL
:
1183 pp_string (pp
, "parallel");
1185 case OMP_CLAUSE_SECTIONS
:
1186 pp_string (pp
, "sections");
1188 case OMP_CLAUSE_TASKGROUP
:
1189 pp_string (pp
, "taskgroup");
1191 case OMP_CLAUSE_NOGROUP
:
1192 pp_string (pp
, "nogroup");
1194 case OMP_CLAUSE_THREADS
:
1195 pp_string (pp
, "threads");
1197 case OMP_CLAUSE_SIMD
:
1198 pp_string (pp
, "simd");
1200 case OMP_CLAUSE_INDEPENDENT
:
1201 pp_string (pp
, "independent");
1203 case OMP_CLAUSE_TILE
:
1204 pp_string (pp
, "tile(");
1205 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1207 pp_right_paren (pp
);
1210 case OMP_CLAUSE__GRIDDIM_
:
1211 pp_string (pp
, "_griddim_(");
1212 pp_unsigned_wide_integer (pp
, OMP_CLAUSE__GRIDDIM__DIMENSION (clause
));
1214 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__SIZE (clause
), spc
, flags
,
1217 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__GROUP (clause
), spc
, flags
,
1219 pp_right_paren (pp
);
1221 case OMP_CLAUSE_IF_PRESENT
:
1222 pp_string (pp
, "if_present");
1224 case OMP_CLAUSE_FINALIZE
:
1225 pp_string (pp
, "finalize");
1234 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1235 dump_generic_node. */
1238 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
1246 dump_omp_clause (pp
, clause
, spc
, flags
);
1247 clause
= OMP_CLAUSE_CHAIN (clause
);
1255 /* Dump location LOC to PP. */
1258 dump_location (pretty_printer
*pp
, location_t loc
)
1260 expanded_location xloc
= expand_location (loc
);
1262 pp_left_bracket (pp
);
1265 pp_string (pp
, xloc
.file
);
1266 pp_string (pp
, ":");
1268 pp_decimal_int (pp
, xloc
.line
);
1270 pp_decimal_int (pp
, xloc
.column
);
1271 pp_string (pp
, "] ");
1275 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1276 dump_generic_node. */
1279 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, dump_flags_t flags
)
1283 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1285 if (flags
& TDF_ADDRESS
)
1286 pp_printf (pp
, "[%p] ", (void *) block
);
1288 if (TREE_ASM_WRITTEN (block
))
1289 pp_string (pp
, "[written] ");
1291 if (flags
& TDF_SLIM
)
1294 if (BLOCK_SOURCE_LOCATION (block
))
1295 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1297 newline_and_indent (pp
, spc
+ 2);
1299 if (BLOCK_SUPERCONTEXT (block
))
1301 pp_string (pp
, "SUPERCONTEXT: ");
1302 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1303 flags
| TDF_SLIM
, false);
1304 newline_and_indent (pp
, spc
+ 2);
1307 if (BLOCK_SUBBLOCKS (block
))
1309 pp_string (pp
, "SUBBLOCKS: ");
1310 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1312 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1315 newline_and_indent (pp
, spc
+ 2);
1318 if (BLOCK_CHAIN (block
))
1320 pp_string (pp
, "SIBLINGS: ");
1321 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1323 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1326 newline_and_indent (pp
, spc
+ 2);
1329 if (BLOCK_VARS (block
))
1331 pp_string (pp
, "VARS: ");
1332 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1334 dump_generic_node (pp
, t
, 0, flags
, false);
1337 newline_and_indent (pp
, spc
+ 2);
1340 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1343 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1345 pp_string (pp
, "NONLOCALIZED_VARS: ");
1346 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1348 dump_generic_node (pp
, t
, 0, flags
, false);
1351 newline_and_indent (pp
, spc
+ 2);
1354 if (BLOCK_ABSTRACT_ORIGIN (block
))
1356 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1357 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1358 flags
| TDF_SLIM
, false);
1359 newline_and_indent (pp
, spc
+ 2);
1362 if (BLOCK_FRAGMENT_ORIGIN (block
))
1364 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1365 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1366 flags
| TDF_SLIM
, false);
1367 newline_and_indent (pp
, spc
+ 2);
1370 if (BLOCK_FRAGMENT_CHAIN (block
))
1372 pp_string (pp
, "FRAGMENT_CHAIN: ");
1373 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1375 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1378 newline_and_indent (pp
, spc
+ 2);
1382 /* Dump #pragma omp atomic memory order clause. */
1385 dump_omp_atomic_memory_order (pretty_printer
*pp
, enum omp_memory_order mo
)
1389 case OMP_MEMORY_ORDER_RELAXED
:
1390 pp_string (pp
, " relaxed");
1392 case OMP_MEMORY_ORDER_SEQ_CST
:
1393 pp_string (pp
, " seq_cst");
1395 case OMP_MEMORY_ORDER_ACQ_REL
:
1396 pp_string (pp
, " acq_rel");
1398 case OMP_MEMORY_ORDER_ACQUIRE
:
1399 pp_string (pp
, " acquire");
1401 case OMP_MEMORY_ORDER_RELEASE
:
1402 pp_string (pp
, " release");
1404 case OMP_MEMORY_ORDER_UNSPECIFIED
:
1411 /* Helper to dump a MEM_REF node. */
1414 dump_mem_ref (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
)
1416 if (flags
& TDF_GIMPLE
)
1418 pp_string (pp
, "__MEM <");
1419 dump_generic_node (pp
, TREE_TYPE (node
),
1420 spc
, flags
| TDF_SLIM
, false);
1421 if (TYPE_ALIGN (TREE_TYPE (node
))
1422 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
1424 pp_string (pp
, ", ");
1425 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
1428 pp_string (pp
, " (");
1429 if (TREE_TYPE (TREE_OPERAND (node
, 0))
1430 != TREE_TYPE (TREE_OPERAND (node
, 1)))
1433 dump_generic_node (pp
, TREE_TYPE (TREE_OPERAND (node
, 1)),
1434 spc
, flags
| TDF_SLIM
, false);
1435 pp_right_paren (pp
);
1437 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1438 spc
, flags
| TDF_SLIM
, false);
1439 if (! integer_zerop (TREE_OPERAND (node
, 1)))
1441 pp_string (pp
, " + ");
1442 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1443 spc
, flags
| TDF_SLIM
, false);
1445 pp_right_paren (pp
);
1447 else if (integer_zerop (TREE_OPERAND (node
, 1))
1448 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1449 infer them and MEM_ATTR caching will share MEM_REFs
1450 with differently-typed op0s. */
1451 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1452 /* Released SSA_NAMES have no TREE_TYPE. */
1453 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1454 /* Same pointer types, but ignoring POINTER_TYPE vs.
1456 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1457 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1458 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1459 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1460 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1461 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1462 /* Same value types ignoring qualifiers. */
1463 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1464 == TYPE_MAIN_VARIANT
1465 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1466 && (!(flags
& TDF_ALIAS
)
1467 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1469 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1471 /* Enclose pointers to arrays in parentheses. */
1472 tree op0
= TREE_OPERAND (node
, 0);
1473 tree op0type
= TREE_TYPE (op0
);
1474 if (POINTER_TYPE_P (op0type
)
1475 && TREE_CODE (TREE_TYPE (op0type
)) == ARRAY_TYPE
)
1478 dump_generic_node (pp
, op0
, spc
, flags
, false);
1479 if (POINTER_TYPE_P (op0type
)
1480 && TREE_CODE (TREE_TYPE (op0type
)) == ARRAY_TYPE
)
1481 pp_right_paren (pp
);
1484 dump_generic_node (pp
,
1485 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1490 pp_string (pp
, "MEM");
1492 tree nodetype
= TREE_TYPE (node
);
1493 tree op0
= TREE_OPERAND (node
, 0);
1494 tree op1
= TREE_OPERAND (node
, 1);
1495 tree op1type
= TYPE_MAIN_VARIANT (TREE_TYPE (op1
));
1497 tree op0size
= TYPE_SIZE (nodetype
);
1498 tree op1size
= TYPE_SIZE (TREE_TYPE (op1type
));
1500 if (!op0size
|| !op1size
1501 || !operand_equal_p (op0size
, op1size
, 0))
1503 pp_string (pp
, " <");
1504 /* If the size of the type of the operand is not the same
1505 as the size of the MEM_REF expression include the type
1506 of the latter similar to the TDF_GIMPLE output to make
1507 it clear how many bytes of memory are being accessed. */
1508 dump_generic_node (pp
, nodetype
, spc
, flags
| TDF_SLIM
, false);
1509 pp_string (pp
, "> ");
1512 pp_string (pp
, "[(");
1513 dump_generic_node (pp
, op1type
, spc
, flags
| TDF_SLIM
, false);
1514 pp_right_paren (pp
);
1515 dump_generic_node (pp
, op0
, spc
, flags
, false);
1516 if (!integer_zerop (op1
))
1517 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1519 pp_string (pp
, " + ");
1520 dump_generic_node (pp
, op1
, spc
, flags
, false);
1522 if ((flags
& TDF_ALIAS
)
1523 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1525 pp_string (pp
, " clique ");
1526 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1527 pp_string (pp
, " base ");
1528 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1530 pp_right_bracket (pp
);
1534 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1535 indent. FLAGS specifies details to show in the dump (see TDF_* in
1536 dumpfile.h). If IS_STMT is true, the object printed is considered
1537 to be a statement and it is terminated by ';' if appropriate. */
1540 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
,
1547 enum tree_code code
;
1549 if (node
== NULL_TREE
)
1552 is_expr
= EXPR_P (node
);
1554 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1555 pp_printf (pp
, "<&%p> ", (void *)node
);
1557 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1558 dump_location (pp
, EXPR_LOCATION (node
));
1560 code
= TREE_CODE (node
);
1564 pp_string (pp
, "<<< error >>>");
1567 case IDENTIFIER_NODE
:
1568 pp_tree_identifier (pp
, node
);
1572 while (node
&& node
!= error_mark_node
)
1574 if (TREE_PURPOSE (node
))
1576 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1579 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1580 node
= TREE_CHAIN (node
);
1581 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1590 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1596 if (TREE_VEC_LENGTH (node
) > 0)
1598 size_t len
= TREE_VEC_LENGTH (node
);
1599 for (i
= 0; i
< len
- 1; i
++)
1601 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1606 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1615 case FIXED_POINT_TYPE
:
1621 unsigned int quals
= TYPE_QUALS (node
);
1622 enum tree_code_class tclass
;
1624 if (quals
& TYPE_QUAL_ATOMIC
)
1625 pp_string (pp
, "atomic ");
1626 if (quals
& TYPE_QUAL_CONST
)
1627 pp_string (pp
, "const ");
1628 else if (quals
& TYPE_QUAL_VOLATILE
)
1629 pp_string (pp
, "volatile ");
1630 else if (quals
& TYPE_QUAL_RESTRICT
)
1631 pp_string (pp
, "restrict ");
1633 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1635 pp_string (pp
, "<address-space-");
1636 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1637 pp_string (pp
, "> ");
1640 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1642 if (tclass
== tcc_declaration
)
1644 if (DECL_NAME (node
))
1645 dump_decl_name (pp
, node
, flags
);
1647 pp_string (pp
, "<unnamed type decl>");
1649 else if (tclass
== tcc_type
)
1651 if (TYPE_NAME (node
))
1653 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1654 pp_tree_identifier (pp
, TYPE_NAME (node
));
1655 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1656 && DECL_NAME (TYPE_NAME (node
)))
1657 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1659 pp_string (pp
, "<unnamed type>");
1661 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1663 pp_string (pp
, "vector");
1665 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1666 pp_string (pp
, ") ");
1667 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1669 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1671 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1672 pp_string (pp
, (TYPE_UNSIGNED (node
)
1675 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1676 pp_string (pp
, (TYPE_UNSIGNED (node
)
1679 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1680 pp_string (pp
, (TYPE_UNSIGNED (node
)
1683 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1684 pp_string (pp
, (TYPE_UNSIGNED (node
)
1687 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1688 pp_string (pp
, (TYPE_UNSIGNED (node
)
1689 ? "unsigned long long"
1690 : "signed long long"));
1691 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1692 && pow2p_hwi (TYPE_PRECISION (node
)))
1694 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1695 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1696 pp_string (pp
, "_t");
1700 pp_string (pp
, (TYPE_UNSIGNED (node
)
1701 ? "<unnamed-unsigned:"
1702 : "<unnamed-signed:"));
1703 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1707 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1709 pp_string (pp
, "__complex__ ");
1710 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1712 else if (TREE_CODE (node
) == REAL_TYPE
)
1714 pp_string (pp
, "<float:");
1715 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1718 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1720 pp_string (pp
, "<fixed-point-");
1721 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1722 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1725 else if (TREE_CODE (node
) == VOID_TYPE
)
1726 pp_string (pp
, "void");
1728 pp_string (pp
, "<unnamed type>");
1734 case REFERENCE_TYPE
:
1735 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1737 if (TREE_TYPE (node
) == NULL
)
1739 pp_string (pp
, str
);
1740 pp_string (pp
, "<null type>");
1742 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1744 tree fnode
= TREE_TYPE (node
);
1746 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1749 pp_string (pp
, str
);
1750 if (TYPE_IDENTIFIER (node
))
1751 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1752 else if (flags
& TDF_NOUID
)
1753 pp_printf (pp
, "<Txxxx>");
1755 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1757 pp_right_paren (pp
);
1758 dump_function_declaration (pp
, fnode
, spc
, flags
);
1762 unsigned int quals
= TYPE_QUALS (node
);
1764 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1766 pp_string (pp
, str
);
1768 if (quals
& TYPE_QUAL_CONST
)
1769 pp_string (pp
, " const");
1770 if (quals
& TYPE_QUAL_VOLATILE
)
1771 pp_string (pp
, " volatile");
1772 if (quals
& TYPE_QUAL_RESTRICT
)
1773 pp_string (pp
, " restrict");
1775 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1777 pp_string (pp
, " <address-space-");
1778 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1782 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1783 pp_string (pp
, " {ref-all}");
1792 dump_mem_ref (pp
, node
, spc
, flags
);
1795 case TARGET_MEM_REF
:
1797 const char *sep
= "";
1800 pp_string (pp
, "MEM[");
1802 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1804 pp_string (pp
, sep
);
1806 pp_string (pp
, "symbol: ");
1807 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1812 pp_string (pp
, sep
);
1814 pp_string (pp
, "base: ");
1815 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1817 tmp
= TMR_INDEX2 (node
);
1820 pp_string (pp
, sep
);
1822 pp_string (pp
, "base: ");
1823 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1825 tmp
= TMR_INDEX (node
);
1828 pp_string (pp
, sep
);
1830 pp_string (pp
, "index: ");
1831 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1833 tmp
= TMR_STEP (node
);
1836 pp_string (pp
, sep
);
1838 pp_string (pp
, "step: ");
1839 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1841 tmp
= TMR_OFFSET (node
);
1844 pp_string (pp
, sep
);
1846 pp_string (pp
, "offset: ");
1847 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1849 pp_right_bracket (pp
);
1857 /* Print the innermost component type. */
1858 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1859 tmp
= TREE_TYPE (tmp
))
1861 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1863 /* Print the dimensions. */
1864 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1865 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1871 case QUAL_UNION_TYPE
:
1873 unsigned int quals
= TYPE_QUALS (node
);
1875 if (quals
& TYPE_QUAL_ATOMIC
)
1876 pp_string (pp
, "atomic ");
1877 if (quals
& TYPE_QUAL_CONST
)
1878 pp_string (pp
, "const ");
1879 if (quals
& TYPE_QUAL_VOLATILE
)
1880 pp_string (pp
, "volatile ");
1882 /* Print the name of the structure. */
1883 if (TREE_CODE (node
) == RECORD_TYPE
)
1884 pp_string (pp
, "struct ");
1885 else if (TREE_CODE (node
) == UNION_TYPE
)
1886 pp_string (pp
, "union ");
1888 if (TYPE_NAME (node
))
1889 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1890 else if (!(flags
& TDF_SLIM
))
1891 /* FIXME: If we eliminate the 'else' above and attempt
1892 to show the fields for named types, we may get stuck
1893 following a cycle of pointers to structs. The alleged
1894 self-reference check in print_struct_decl will not detect
1895 cycles involving more than one pointer or struct type. */
1896 print_struct_decl (pp
, node
, spc
, flags
);
1905 if (flags
& TDF_GIMPLE
1906 && (POINTER_TYPE_P (TREE_TYPE (node
))
1907 || (TYPE_PRECISION (TREE_TYPE (node
))
1908 < TYPE_PRECISION (integer_type_node
))
1909 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1
1910 || tree_int_cst_sgn (node
) < 0))
1912 pp_string (pp
, "_Literal (");
1913 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1914 pp_string (pp
, ") ");
1916 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
1917 && ! (flags
& TDF_GIMPLE
))
1919 /* In the case of a pointer, one may want to divide by the
1920 size of the pointed-to type. Unfortunately, this not
1921 straightforward. The C front-end maps expressions
1926 in such a way that the two INTEGER_CST nodes for "5" have
1927 different values but identical types. In the latter
1928 case, the 5 is multiplied by sizeof (int) in c-common.c
1929 (pointer_int_sum) to convert it to a byte address, and
1930 yet the type of the node is left unchanged. Argh. What
1931 is consistent though is that the number value corresponds
1932 to bytes (UNITS) offset.
1934 NB: Neither of the following divisors can be trivially
1935 used to recover the original literal:
1937 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1938 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1939 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1940 pp_string (pp
, "B"); /* pseudo-unit */
1942 else if (tree_fits_shwi_p (node
))
1943 pp_wide_integer (pp
, tree_to_shwi (node
));
1944 else if (tree_fits_uhwi_p (node
))
1945 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1948 wide_int val
= wi::to_wide (node
);
1950 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1955 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
1956 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
1958 if ((flags
& TDF_GIMPLE
)
1959 && ! (POINTER_TYPE_P (TREE_TYPE (node
))
1960 || (TYPE_PRECISION (TREE_TYPE (node
))
1961 < TYPE_PRECISION (integer_type_node
))
1962 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1964 if (TYPE_UNSIGNED (TREE_TYPE (node
)))
1965 pp_character (pp
, 'u');
1966 if (TYPE_PRECISION (TREE_TYPE (node
))
1967 == TYPE_PRECISION (unsigned_type_node
))
1969 else if (TYPE_PRECISION (TREE_TYPE (node
))
1970 == TYPE_PRECISION (long_unsigned_type_node
))
1971 pp_character (pp
, 'l');
1972 else if (TYPE_PRECISION (TREE_TYPE (node
))
1973 == TYPE_PRECISION (long_long_unsigned_type_node
))
1974 pp_string (pp
, "ll");
1976 if (TREE_OVERFLOW (node
))
1977 pp_string (pp
, "(OVF)");
1981 pp_string (pp
, "POLY_INT_CST [");
1982 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, 0), spc
, flags
, false);
1983 for (unsigned int i
= 1; i
< NUM_POLY_INT_COEFFS
; ++i
)
1985 pp_string (pp
, ", ");
1986 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, i
),
1989 pp_string (pp
, "]");
1993 /* Code copied from print_node. */
1996 if (TREE_OVERFLOW (node
))
1997 pp_string (pp
, " overflow");
1999 d
= TREE_REAL_CST (node
);
2000 if (REAL_VALUE_ISINF (d
))
2001 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
2002 else if (REAL_VALUE_ISNAN (d
))
2003 pp_string (pp
, " Nan");
2007 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
2008 pp_string (pp
, string
);
2016 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
2017 pp_string (pp
, string
);
2022 pp_string (pp
, "__complex__ (");
2023 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
2024 pp_string (pp
, ", ");
2025 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
2026 pp_right_paren (pp
);
2031 pp_string (pp
, "\"");
2032 if (unsigned nbytes
= TREE_STRING_LENGTH (node
))
2033 pretty_print_string (pp
, TREE_STRING_POINTER (node
), nbytes
);
2034 pp_string (pp
, "\"");
2041 pp_string (pp
, "{ ");
2042 unsigned HOST_WIDE_INT nunits
;
2043 if (!VECTOR_CST_NELTS (node
).is_constant (&nunits
))
2044 nunits
= vector_cst_encoded_nelts (node
);
2045 for (i
= 0; i
< nunits
; ++i
)
2048 pp_string (pp
, ", ");
2049 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
2052 if (!VECTOR_CST_NELTS (node
).is_constant ())
2053 pp_string (pp
, ", ...");
2054 pp_string (pp
, " }");
2060 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2062 if (TREE_CODE (node
) == METHOD_TYPE
)
2064 if (TYPE_METHOD_BASETYPE (node
))
2065 dump_generic_node (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
2068 pp_string (pp
, "<null method basetype>");
2069 pp_colon_colon (pp
);
2071 if (TYPE_IDENTIFIER (node
))
2072 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
2073 else if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
2074 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
2075 else if (flags
& TDF_NOUID
)
2076 pp_printf (pp
, "<Txxxx>");
2078 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
2079 dump_function_declaration (pp
, node
, spc
, flags
);
2084 dump_decl_name (pp
, node
, flags
);
2088 if (DECL_NAME (node
))
2089 dump_decl_name (pp
, node
, flags
);
2090 else if (LABEL_DECL_UID (node
) != -1)
2092 if (flags
& TDF_GIMPLE
)
2093 pp_printf (pp
, "L%d", (int) LABEL_DECL_UID (node
));
2095 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
2099 if (flags
& TDF_NOUID
)
2100 pp_string (pp
, "<D.xxxx>");
2103 if (flags
& TDF_GIMPLE
)
2104 pp_printf (pp
, "<D%u>", DECL_UID (node
));
2106 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
2112 if (DECL_IS_BUILTIN (node
))
2114 /* Don't print the declaration of built-in types. */
2117 if (DECL_NAME (node
))
2118 dump_decl_name (pp
, node
, flags
);
2119 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
2121 pp_string (pp
, (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
2122 ? "union" : "struct "));
2123 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2126 pp_string (pp
, "<anon>");
2132 case DEBUG_EXPR_DECL
:
2133 case NAMESPACE_DECL
:
2135 dump_decl_name (pp
, node
, flags
);
2139 pp_string (pp
, "<retval>");
2143 op0
= TREE_OPERAND (node
, 0);
2146 && (TREE_CODE (op0
) == INDIRECT_REF
2147 || (TREE_CODE (op0
) == MEM_REF
2148 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
2149 && integer_zerop (TREE_OPERAND (op0
, 1))
2150 /* Dump the types of INTEGER_CSTs explicitly, for we
2151 can't infer them and MEM_ATTR caching will share
2152 MEM_REFs with differently-typed op0s. */
2153 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
2154 /* Released SSA_NAMES have no TREE_TYPE. */
2155 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
2156 /* Same pointer types, but ignoring POINTER_TYPE vs.
2158 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2159 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2160 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2161 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2162 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2163 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2164 /* Same value types ignoring qualifiers. */
2165 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
2166 == TYPE_MAIN_VARIANT
2167 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
2168 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
2170 op0
= TREE_OPERAND (op0
, 0);
2173 if (op_prio (op0
) < op_prio (node
))
2175 dump_generic_node (pp
, op0
, spc
, flags
, false);
2176 if (op_prio (op0
) < op_prio (node
))
2177 pp_right_paren (pp
);
2178 pp_string (pp
, str
);
2179 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2180 op0
= component_ref_field_offset (node
);
2181 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
2183 pp_string (pp
, "{off: ");
2184 dump_generic_node (pp
, op0
, spc
, flags
, false);
2185 pp_right_brace (pp
);
2190 if (flags
& TDF_GIMPLE
)
2192 pp_string (pp
, "__BIT_FIELD_REF <");
2193 dump_generic_node (pp
, TREE_TYPE (node
),
2194 spc
, flags
| TDF_SLIM
, false);
2195 if (TYPE_ALIGN (TREE_TYPE (node
))
2196 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
2198 pp_string (pp
, ", ");
2199 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
2202 pp_string (pp
, " (");
2203 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
,
2204 flags
| TDF_SLIM
, false);
2205 pp_string (pp
, ", ");
2206 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
,
2207 flags
| TDF_SLIM
, false);
2208 pp_string (pp
, ", ");
2209 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
,
2210 flags
| TDF_SLIM
, false);
2211 pp_right_paren (pp
);
2215 pp_string (pp
, "BIT_FIELD_REF <");
2216 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2217 pp_string (pp
, ", ");
2218 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2219 pp_string (pp
, ", ");
2220 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2225 case BIT_INSERT_EXPR
:
2226 pp_string (pp
, "BIT_INSERT_EXPR <");
2227 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2228 pp_string (pp
, ", ");
2229 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2230 pp_string (pp
, ", ");
2231 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2232 pp_string (pp
, " (");
2233 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
2235 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
2237 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
2239 pp_string (pp
, " bits)>");
2243 case ARRAY_RANGE_REF
:
2244 op0
= TREE_OPERAND (node
, 0);
2245 if (op_prio (op0
) < op_prio (node
))
2247 dump_generic_node (pp
, op0
, spc
, flags
, false);
2248 if (op_prio (op0
) < op_prio (node
))
2249 pp_right_paren (pp
);
2250 pp_left_bracket (pp
);
2251 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2252 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
2253 pp_string (pp
, " ...");
2254 pp_right_bracket (pp
);
2256 op0
= array_ref_low_bound (node
);
2257 op1
= array_ref_element_size (node
);
2259 if (!integer_zerop (op0
)
2260 || TREE_OPERAND (node
, 2)
2261 || TREE_OPERAND (node
, 3))
2263 pp_string (pp
, "{lb: ");
2264 dump_generic_node (pp
, op0
, spc
, flags
, false);
2265 pp_string (pp
, " sz: ");
2266 dump_generic_node (pp
, op1
, spc
, flags
, false);
2267 pp_right_brace (pp
);
2273 unsigned HOST_WIDE_INT ix
;
2275 bool is_struct_init
= false;
2276 bool is_array_init
= false;
2279 if (TREE_CLOBBER_P (node
))
2280 pp_string (pp
, "CLOBBER");
2281 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
2282 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
2283 is_struct_init
= true;
2284 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
2285 && TYPE_DOMAIN (TREE_TYPE (node
))
2286 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
2287 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
2290 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
2291 is_array_init
= true;
2292 curidx
= wi::to_widest (minv
);
2294 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
2301 dump_generic_node (pp
, field
, spc
, flags
, false);
2304 else if (is_array_init
2305 && (TREE_CODE (field
) != INTEGER_CST
2306 || curidx
!= wi::to_widest (field
)))
2308 pp_left_bracket (pp
);
2309 if (TREE_CODE (field
) == RANGE_EXPR
)
2311 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
2313 pp_string (pp
, " ... ");
2314 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
2316 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
2317 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
2320 dump_generic_node (pp
, field
, spc
, flags
, false);
2321 if (TREE_CODE (field
) == INTEGER_CST
)
2322 curidx
= wi::to_widest (field
);
2323 pp_string (pp
, "]=");
2328 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
2329 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
2330 val
= TREE_OPERAND (val
, 0);
2331 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
2332 dump_decl_name (pp
, val
, flags
);
2334 dump_generic_node (pp
, val
, spc
, flags
, false);
2335 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2341 pp_right_brace (pp
);
2348 if (flags
& TDF_SLIM
)
2350 pp_string (pp
, "<COMPOUND_EXPR>");
2354 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2355 spc
, flags
, !(flags
& TDF_SLIM
));
2356 if (flags
& TDF_SLIM
)
2357 newline_and_indent (pp
, spc
);
2364 for (tp
= &TREE_OPERAND (node
, 1);
2365 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2366 tp
= &TREE_OPERAND (*tp
, 1))
2368 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2369 spc
, flags
, !(flags
& TDF_SLIM
));
2370 if (flags
& TDF_SLIM
)
2371 newline_and_indent (pp
, spc
);
2379 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2383 case STATEMENT_LIST
:
2385 tree_stmt_iterator si
;
2388 if (flags
& TDF_SLIM
)
2390 pp_string (pp
, "<STATEMENT_LIST>");
2394 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2397 newline_and_indent (pp
, spc
);
2400 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2407 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2412 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2417 pp_string (pp
, "TARGET_EXPR <");
2418 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2421 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2426 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2431 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2433 pp_string (pp
, "if (");
2434 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2435 pp_right_paren (pp
);
2436 /* The lowered cond_exprs should always be printed in full. */
2437 if (COND_EXPR_THEN (node
)
2438 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2439 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2440 && COND_EXPR_ELSE (node
)
2441 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2442 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2445 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2447 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2449 pp_string (pp
, " else ");
2450 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2454 else if (!(flags
& TDF_SLIM
))
2456 /* Output COND_EXPR_THEN. */
2457 if (COND_EXPR_THEN (node
))
2459 newline_and_indent (pp
, spc
+2);
2461 newline_and_indent (pp
, spc
+4);
2462 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2464 newline_and_indent (pp
, spc
+2);
2465 pp_right_brace (pp
);
2468 /* Output COND_EXPR_ELSE. */
2469 if (COND_EXPR_ELSE (node
)
2470 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2472 newline_and_indent (pp
, spc
);
2473 pp_string (pp
, "else");
2474 newline_and_indent (pp
, spc
+2);
2476 newline_and_indent (pp
, spc
+4);
2477 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2479 newline_and_indent (pp
, spc
+2);
2480 pp_right_brace (pp
);
2487 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2491 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2495 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2501 if (!(flags
& TDF_SLIM
))
2503 if (BIND_EXPR_VARS (node
))
2507 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2509 print_declaration (pp
, op0
, spc
+2, flags
);
2514 newline_and_indent (pp
, spc
+2);
2515 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2516 newline_and_indent (pp
, spc
);
2517 pp_right_brace (pp
);
2523 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2524 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2528 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2531 /* Print parameters. */
2536 call_expr_arg_iterator iter
;
2537 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2539 dump_generic_node (pp
, arg
, spc
, flags
, false);
2540 if (more_call_expr_args_p (&iter
))
2547 if (CALL_EXPR_VA_ARG_PACK (node
))
2549 if (call_expr_nargs (node
) > 0)
2554 pp_string (pp
, "__builtin_va_arg_pack ()");
2556 pp_right_paren (pp
);
2558 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2561 pp_string (pp
, " [static-chain: ");
2562 dump_generic_node (pp
, op1
, spc
, flags
, false);
2563 pp_right_bracket (pp
);
2566 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2567 pp_string (pp
, " [return slot optimization]");
2568 if (CALL_EXPR_TAILCALL (node
))
2569 pp_string (pp
, " [tail call]");
2572 case WITH_CLEANUP_EXPR
:
2576 case CLEANUP_POINT_EXPR
:
2577 pp_string (pp
, "<<cleanup_point ");
2578 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2579 pp_string (pp
, ">>");
2582 case PLACEHOLDER_EXPR
:
2583 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2584 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2588 /* Binary arithmetic and logic expressions. */
2589 case WIDEN_SUM_EXPR
:
2590 case WIDEN_MULT_EXPR
:
2592 case MULT_HIGHPART_EXPR
:
2594 case POINTER_PLUS_EXPR
:
2595 case POINTER_DIFF_EXPR
:
2597 case TRUNC_DIV_EXPR
:
2599 case FLOOR_DIV_EXPR
:
2600 case ROUND_DIV_EXPR
:
2601 case TRUNC_MOD_EXPR
:
2603 case FLOOR_MOD_EXPR
:
2604 case ROUND_MOD_EXPR
:
2606 case EXACT_DIV_EXPR
:
2611 case WIDEN_LSHIFT_EXPR
:
2615 case TRUTH_ANDIF_EXPR
:
2616 case TRUTH_ORIF_EXPR
:
2617 case TRUTH_AND_EXPR
:
2619 case TRUTH_XOR_EXPR
:
2633 case UNORDERED_EXPR
:
2635 const char *op
= op_symbol (node
);
2636 op0
= TREE_OPERAND (node
, 0);
2637 op1
= TREE_OPERAND (node
, 1);
2639 /* When the operands are expressions with less priority,
2640 keep semantics of the tree representation. */
2641 if (op_prio (op0
) <= op_prio (node
))
2644 dump_generic_node (pp
, op0
, spc
, flags
, false);
2645 pp_right_paren (pp
);
2648 dump_generic_node (pp
, op0
, spc
, flags
, false);
2654 /* When the operands are expressions with less priority,
2655 keep semantics of the tree representation. */
2656 if (op_prio (op1
) <= op_prio (node
))
2659 dump_generic_node (pp
, op1
, spc
, flags
, false);
2660 pp_right_paren (pp
);
2663 dump_generic_node (pp
, op1
, spc
, flags
, false);
2667 /* Unary arithmetic and logic expressions. */
2670 case TRUTH_NOT_EXPR
:
2672 case PREDECREMENT_EXPR
:
2673 case PREINCREMENT_EXPR
:
2675 if (TREE_CODE (node
) == ADDR_EXPR
2676 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2677 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2678 ; /* Do not output '&' for strings and function pointers. */
2680 pp_string (pp
, op_symbol (node
));
2682 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2685 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2686 pp_right_paren (pp
);
2689 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2692 case POSTDECREMENT_EXPR
:
2693 case POSTINCREMENT_EXPR
:
2694 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2697 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2698 pp_right_paren (pp
);
2701 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2702 pp_string (pp
, op_symbol (node
));
2706 pp_string (pp
, "MIN_EXPR <");
2707 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2708 pp_string (pp
, ", ");
2709 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2714 pp_string (pp
, "MAX_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
, "ABS_EXPR <");
2723 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2728 pp_string (pp
, "ABSU_EXPR <");
2729 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2737 case ADDR_SPACE_CONVERT_EXPR
:
2738 case FIXED_CONVERT_EXPR
:
2739 case FIX_TRUNC_EXPR
:
2742 type
= TREE_TYPE (node
);
2743 op0
= TREE_OPERAND (node
, 0);
2744 if (type
!= TREE_TYPE (op0
))
2747 dump_generic_node (pp
, type
, spc
, flags
, false);
2748 pp_string (pp
, ") ");
2750 if (op_prio (op0
) < op_prio (node
))
2752 dump_generic_node (pp
, op0
, spc
, flags
, false);
2753 if (op_prio (op0
) < op_prio (node
))
2754 pp_right_paren (pp
);
2757 case VIEW_CONVERT_EXPR
:
2758 if (flags
& TDF_GIMPLE
)
2759 pp_string (pp
, "__VIEW_CONVERT <");
2761 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2762 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2763 pp_string (pp
, ">(");
2764 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2765 pp_right_paren (pp
);
2769 pp_string (pp
, "((");
2770 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2771 pp_string (pp
, "))");
2774 case NON_LVALUE_EXPR
:
2775 pp_string (pp
, "NON_LVALUE_EXPR <");
2776 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2781 pp_string (pp
, "SAVE_EXPR <");
2782 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2787 pp_string (pp
, "COMPLEX_EXPR <");
2788 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2789 pp_string (pp
, ", ");
2790 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2795 pp_string (pp
, "CONJ_EXPR <");
2796 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2801 if (flags
& TDF_GIMPLE
)
2803 pp_string (pp
, "__real ");
2804 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2808 pp_string (pp
, "REALPART_EXPR <");
2809 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2815 if (flags
& TDF_GIMPLE
)
2817 pp_string (pp
, "__imag ");
2818 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2822 pp_string (pp
, "IMAGPART_EXPR <");
2823 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2829 pp_string (pp
, "VA_ARG_EXPR <");
2830 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2834 case TRY_FINALLY_EXPR
:
2835 case TRY_CATCH_EXPR
:
2836 pp_string (pp
, "try");
2837 newline_and_indent (pp
, spc
+2);
2839 newline_and_indent (pp
, spc
+4);
2840 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2841 newline_and_indent (pp
, spc
+2);
2842 pp_right_brace (pp
);
2843 newline_and_indent (pp
, spc
);
2844 if (TREE_CODE (node
) == TRY_CATCH_EXPR
)
2846 node
= TREE_OPERAND (node
, 1);
2847 pp_string (pp
, "catch");
2851 gcc_assert (TREE_CODE (node
) == TRY_FINALLY_EXPR
);
2852 node
= TREE_OPERAND (node
, 1);
2853 pp_string (pp
, "finally");
2854 if (TREE_CODE (node
) == EH_ELSE_EXPR
)
2856 newline_and_indent (pp
, spc
+2);
2858 newline_and_indent (pp
, spc
+4);
2859 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4,
2861 newline_and_indent (pp
, spc
+2);
2862 pp_right_brace (pp
);
2863 newline_and_indent (pp
, spc
);
2864 node
= TREE_OPERAND (node
, 1);
2865 pp_string (pp
, "else");
2868 newline_and_indent (pp
, spc
+2);
2870 newline_and_indent (pp
, spc
+4);
2871 dump_generic_node (pp
, node
, spc
+4, flags
, true);
2872 newline_and_indent (pp
, spc
+2);
2873 pp_right_brace (pp
);
2878 pp_string (pp
, "catch (");
2879 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2880 pp_right_paren (pp
);
2881 newline_and_indent (pp
, spc
+2);
2883 newline_and_indent (pp
, spc
+4);
2884 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2885 newline_and_indent (pp
, spc
+2);
2886 pp_right_brace (pp
);
2890 case EH_FILTER_EXPR
:
2891 pp_string (pp
, "<<<eh_filter (");
2892 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2893 pp_string (pp
, ")>>>");
2894 newline_and_indent (pp
, spc
+2);
2896 newline_and_indent (pp
, spc
+4);
2897 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2898 newline_and_indent (pp
, spc
+2);
2899 pp_right_brace (pp
);
2904 op0
= TREE_OPERAND (node
, 0);
2905 /* If this is for break or continue, don't bother printing it. */
2906 if (DECL_NAME (op0
))
2908 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2909 if (strcmp (name
, "break") == 0
2910 || strcmp (name
, "continue") == 0)
2913 dump_generic_node (pp
, op0
, spc
, flags
, false);
2915 if (DECL_NONLOCAL (op0
))
2916 pp_string (pp
, " [non-local]");
2920 pp_string (pp
, "while (1)");
2921 if (!(flags
& TDF_SLIM
))
2923 newline_and_indent (pp
, spc
+2);
2925 newline_and_indent (pp
, spc
+4);
2926 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2927 newline_and_indent (pp
, spc
+2);
2928 pp_right_brace (pp
);
2934 pp_string (pp
, "// predicted ");
2935 if (PREDICT_EXPR_OUTCOME (node
))
2936 pp_string (pp
, "likely by ");
2938 pp_string (pp
, "unlikely by ");
2939 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2940 pp_string (pp
, " predictor.");
2944 pp_string (pp
, "ANNOTATE_EXPR <");
2945 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2946 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2948 case annot_expr_ivdep_kind
:
2949 pp_string (pp
, ", ivdep");
2951 case annot_expr_unroll_kind
:
2952 pp_printf (pp
, ", unroll %d",
2953 (int) TREE_INT_CST_LOW (TREE_OPERAND (node
, 2)));
2955 case annot_expr_no_vector_kind
:
2956 pp_string (pp
, ", no-vector");
2958 case annot_expr_vector_kind
:
2959 pp_string (pp
, ", vector");
2961 case annot_expr_parallel_kind
:
2962 pp_string (pp
, ", parallel");
2971 pp_string (pp
, "return");
2972 op0
= TREE_OPERAND (node
, 0);
2976 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2977 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2980 dump_generic_node (pp
, op0
, spc
, flags
, false);
2985 pp_string (pp
, "if (");
2986 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2987 pp_string (pp
, ") break");
2991 pp_string (pp
, "switch (");
2992 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2993 pp_right_paren (pp
);
2994 if (!(flags
& TDF_SLIM
))
2996 newline_and_indent (pp
, spc
+2);
2998 if (SWITCH_BODY (node
))
3000 newline_and_indent (pp
, spc
+4);
3001 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
3004 newline_and_indent (pp
, spc
+2);
3005 pp_right_brace (pp
);
3011 op0
= GOTO_DESTINATION (node
);
3012 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
3014 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
3015 if (strcmp (name
, "break") == 0
3016 || strcmp (name
, "continue") == 0)
3018 pp_string (pp
, name
);
3022 pp_string (pp
, "goto ");
3023 dump_generic_node (pp
, op0
, spc
, flags
, false);
3027 pp_string (pp
, "__asm__");
3028 if (ASM_VOLATILE_P (node
))
3029 pp_string (pp
, " __volatile__");
3031 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
3033 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
3035 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
3036 if (ASM_CLOBBERS (node
))
3039 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
3041 pp_right_paren (pp
);
3044 case CASE_LABEL_EXPR
:
3045 if (CASE_LOW (node
) && CASE_HIGH (node
))
3047 pp_string (pp
, "case ");
3048 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
3049 pp_string (pp
, " ... ");
3050 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
3052 else if (CASE_LOW (node
))
3054 pp_string (pp
, "case ");
3055 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
3058 pp_string (pp
, "default");
3063 pp_string (pp
, "OBJ_TYPE_REF(");
3064 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
3066 /* We omit the class type for -fcompare-debug because we may
3067 drop TYPE_BINFO early depending on debug info, and then
3068 virtual_method_call_p would return false, whereas when
3069 TYPE_BINFO is preserved it may still return true and then
3070 we'd print the class type. Compare tree and rtl dumps for
3071 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
3072 for example, at occurrences of OBJ_TYPE_REF. */
3073 if (!(flags
& (TDF_SLIM
| TDF_COMPARE_DEBUG
))
3074 && virtual_method_call_p (node
))
3076 pp_string (pp
, "(");
3077 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
3078 pp_string (pp
, ")");
3080 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
3082 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
3083 pp_right_paren (pp
);
3087 if (SSA_NAME_IDENTIFIER (node
))
3089 if ((flags
& TDF_NOUID
)
3090 && SSA_NAME_VAR (node
)
3091 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
3092 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
3093 else if (! (flags
& TDF_GIMPLE
)
3094 || SSA_NAME_VAR (node
))
3095 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
3099 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
3100 if (SSA_NAME_IS_DEFAULT_DEF (node
))
3101 pp_string (pp
, "(D)");
3102 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
3103 pp_string (pp
, "(ab)");
3106 case WITH_SIZE_EXPR
:
3107 pp_string (pp
, "WITH_SIZE_EXPR <");
3108 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3109 pp_string (pp
, ", ");
3110 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3115 pp_string (pp
, "ASSERT_EXPR <");
3116 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
3117 pp_string (pp
, ", ");
3118 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
3123 pp_string (pp
, "scev_known");
3126 case SCEV_NOT_KNOWN
:
3127 pp_string (pp
, "scev_not_known");
3130 case POLYNOMIAL_CHREC
:
3132 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
3133 pp_string (pp
, ", +, ");
3134 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
3135 pp_printf (pp
, "}_%u", CHREC_VARIABLE (node
));
3139 case REALIGN_LOAD_EXPR
:
3140 pp_string (pp
, "REALIGN_LOAD <");
3141 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3142 pp_string (pp
, ", ");
3143 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3144 pp_string (pp
, ", ");
3145 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3150 pp_string (pp
, " VEC_COND_EXPR < ");
3151 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3152 pp_string (pp
, " , ");
3153 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3154 pp_string (pp
, " , ");
3155 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3156 pp_string (pp
, " > ");
3160 pp_string (pp
, " VEC_PERM_EXPR < ");
3161 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3162 pp_string (pp
, " , ");
3163 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3164 pp_string (pp
, " , ");
3165 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3166 pp_string (pp
, " > ");
3170 pp_string (pp
, " DOT_PROD_EXPR < ");
3171 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3172 pp_string (pp
, ", ");
3173 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3174 pp_string (pp
, ", ");
3175 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3176 pp_string (pp
, " > ");
3179 case WIDEN_MULT_PLUS_EXPR
:
3180 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
3181 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3182 pp_string (pp
, ", ");
3183 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3184 pp_string (pp
, ", ");
3185 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3186 pp_string (pp
, " > ");
3189 case WIDEN_MULT_MINUS_EXPR
:
3190 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
3191 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3192 pp_string (pp
, ", ");
3193 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3194 pp_string (pp
, ", ");
3195 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3196 pp_string (pp
, " > ");
3200 pp_string (pp
, "#pragma acc parallel");
3201 goto dump_omp_clauses_body
;
3204 pp_string (pp
, "#pragma acc kernels");
3205 goto dump_omp_clauses_body
;
3208 pp_string (pp
, "#pragma acc data");
3209 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
3212 case OACC_HOST_DATA
:
3213 pp_string (pp
, "#pragma acc host_data");
3214 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
3218 pp_string (pp
, "#pragma acc declare");
3219 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
3223 pp_string (pp
, "#pragma acc update");
3224 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
3227 case OACC_ENTER_DATA
:
3228 pp_string (pp
, "#pragma acc enter data");
3229 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3232 case OACC_EXIT_DATA
:
3233 pp_string (pp
, "#pragma acc exit data");
3234 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3238 pp_string (pp
, "#pragma acc cache");
3239 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
3243 pp_string (pp
, "#pragma omp parallel");
3244 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
3247 dump_omp_clauses_body
:
3248 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
3252 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
3254 newline_and_indent (pp
, spc
+ 2);
3256 newline_and_indent (pp
, spc
+ 4);
3257 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
3258 newline_and_indent (pp
, spc
+ 2);
3259 pp_right_brace (pp
);
3265 pp_string (pp
, OMP_TASK_BODY (node
) ? "#pragma omp task"
3266 : "#pragma omp taskwait");
3267 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
3271 pp_string (pp
, "#pragma omp for");
3275 pp_string (pp
, "#pragma omp simd");
3278 case OMP_DISTRIBUTE
:
3279 pp_string (pp
, "#pragma omp distribute");
3283 pp_string (pp
, "#pragma omp taskloop");
3287 pp_string (pp
, "#pragma omp loop");
3291 pp_string (pp
, "#pragma acc loop");
3295 pp_string (pp
, "#pragma omp teams");
3296 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
3299 case OMP_TARGET_DATA
:
3300 pp_string (pp
, "#pragma omp target data");
3301 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
3304 case OMP_TARGET_ENTER_DATA
:
3305 pp_string (pp
, "#pragma omp target enter data");
3306 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3310 case OMP_TARGET_EXIT_DATA
:
3311 pp_string (pp
, "#pragma omp target exit data");
3312 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3317 pp_string (pp
, "#pragma omp target");
3318 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3321 case OMP_TARGET_UPDATE
:
3322 pp_string (pp
, "#pragma omp target update");
3323 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3328 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3329 if (!(flags
& TDF_SLIM
))
3333 if (OMP_FOR_PRE_BODY (node
))
3335 newline_and_indent (pp
, spc
+ 2);
3338 newline_and_indent (pp
, spc
);
3339 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3342 if (OMP_FOR_INIT (node
))
3345 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3348 newline_and_indent (pp
, spc
);
3349 pp_string (pp
, "for (");
3350 dump_generic_node (pp
,
3351 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
3353 pp_string (pp
, "; ");
3354 dump_generic_node (pp
,
3355 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
3357 pp_string (pp
, "; ");
3358 dump_generic_node (pp
,
3359 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3361 pp_right_paren (pp
);
3364 if (OMP_FOR_BODY (node
))
3366 newline_and_indent (pp
, spc
+ 2);
3368 newline_and_indent (pp
, spc
+ 4);
3369 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3371 newline_and_indent (pp
, spc
+ 2);
3372 pp_right_brace (pp
);
3374 if (OMP_FOR_INIT (node
))
3375 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3376 if (OMP_FOR_PRE_BODY (node
))
3379 newline_and_indent (pp
, spc
+ 2);
3380 pp_right_brace (pp
);
3387 pp_string (pp
, "#pragma omp sections");
3388 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3392 pp_string (pp
, "#pragma omp section");
3396 if (OMP_SCAN_CLAUSES (node
))
3398 pp_string (pp
, "#pragma omp scan");
3399 dump_omp_clauses (pp
, OMP_SCAN_CLAUSES (node
), spc
, flags
);
3404 pp_string (pp
, "#pragma omp master");
3408 pp_string (pp
, "#pragma omp taskgroup");
3409 dump_omp_clauses (pp
, OMP_TASKGROUP_CLAUSES (node
), spc
, flags
);
3413 pp_string (pp
, "#pragma omp ordered");
3414 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3418 pp_string (pp
, "#pragma omp critical");
3419 if (OMP_CRITICAL_NAME (node
))
3423 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3425 pp_right_paren (pp
);
3427 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3431 pp_string (pp
, "#pragma omp atomic");
3432 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3433 newline_and_indent (pp
, spc
+ 2);
3434 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3438 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3441 case OMP_ATOMIC_READ
:
3442 pp_string (pp
, "#pragma omp atomic read");
3443 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3444 newline_and_indent (pp
, spc
+ 2);
3445 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3449 case OMP_ATOMIC_CAPTURE_OLD
:
3450 case OMP_ATOMIC_CAPTURE_NEW
:
3451 pp_string (pp
, "#pragma omp atomic capture");
3452 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3453 newline_and_indent (pp
, spc
+ 2);
3454 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3458 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3462 pp_string (pp
, "#pragma omp single");
3463 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3467 dump_omp_clause (pp
, node
, spc
, flags
);
3471 case TRANSACTION_EXPR
:
3472 if (TRANSACTION_EXPR_OUTER (node
))
3473 pp_string (pp
, "__transaction_atomic [[outer]]");
3474 else if (TRANSACTION_EXPR_RELAXED (node
))
3475 pp_string (pp
, "__transaction_relaxed");
3477 pp_string (pp
, "__transaction_atomic");
3478 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3480 newline_and_indent (pp
, spc
);
3482 newline_and_indent (pp
, spc
+ 2);
3483 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3484 spc
+ 2, flags
, false);
3485 newline_and_indent (pp
, spc
);
3486 pp_right_brace (pp
);
3491 case VEC_SERIES_EXPR
:
3492 case VEC_WIDEN_MULT_HI_EXPR
:
3493 case VEC_WIDEN_MULT_LO_EXPR
:
3494 case VEC_WIDEN_MULT_EVEN_EXPR
:
3495 case VEC_WIDEN_MULT_ODD_EXPR
:
3496 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3497 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3499 for (str
= get_tree_code_name (code
); *str
; str
++)
3500 pp_character (pp
, TOUPPER (*str
));
3501 pp_string (pp
, " < ");
3502 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3503 pp_string (pp
, ", ");
3504 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3505 pp_string (pp
, " > ");
3508 case VEC_DUPLICATE_EXPR
:
3510 for (str
= get_tree_code_name (code
); *str
; str
++)
3511 pp_character (pp
, TOUPPER (*str
));
3512 pp_string (pp
, " < ");
3513 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3514 pp_string (pp
, " > ");
3517 case VEC_UNPACK_HI_EXPR
:
3518 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3519 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3520 pp_string (pp
, " > ");
3523 case VEC_UNPACK_LO_EXPR
:
3524 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3525 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3526 pp_string (pp
, " > ");
3529 case VEC_UNPACK_FLOAT_HI_EXPR
:
3530 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3531 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3532 pp_string (pp
, " > ");
3535 case VEC_UNPACK_FLOAT_LO_EXPR
:
3536 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3537 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3538 pp_string (pp
, " > ");
3541 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3542 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
3543 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3544 pp_string (pp
, " > ");
3547 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3548 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
3549 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3550 pp_string (pp
, " > ");
3553 case VEC_PACK_TRUNC_EXPR
:
3554 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3555 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3556 pp_string (pp
, ", ");
3557 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3558 pp_string (pp
, " > ");
3561 case VEC_PACK_SAT_EXPR
:
3562 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3563 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3564 pp_string (pp
, ", ");
3565 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3566 pp_string (pp
, " > ");
3569 case VEC_PACK_FIX_TRUNC_EXPR
:
3570 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3571 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3572 pp_string (pp
, ", ");
3573 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3574 pp_string (pp
, " > ");
3577 case VEC_PACK_FLOAT_EXPR
:
3578 pp_string (pp
, " VEC_PACK_FLOAT_EXPR < ");
3579 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3580 pp_string (pp
, ", ");
3581 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3582 pp_string (pp
, " > ");
3586 dump_block_node (pp
, node
, spc
, flags
);
3589 case DEBUG_BEGIN_STMT
:
3590 pp_string (pp
, "# DEBUG BEGIN STMT");
3597 if (is_stmt
&& is_expr
)
3603 /* Print the declaration of a variable. */
3606 print_declaration (pretty_printer
*pp
, tree t
, int spc
, dump_flags_t flags
)
3610 if (TREE_CODE(t
) == NAMELIST_DECL
)
3612 pp_string(pp
, "namelist ");
3613 dump_decl_name (pp
, t
, flags
);
3618 if (TREE_CODE (t
) == TYPE_DECL
)
3619 pp_string (pp
, "typedef ");
3621 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3622 pp_string (pp
, "register ");
3624 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3625 pp_string (pp
, "extern ");
3626 else if (TREE_STATIC (t
))
3627 pp_string (pp
, "static ");
3629 /* Print the type and name. */
3630 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3634 /* Print array's type. */
3635 tmp
= TREE_TYPE (t
);
3636 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3637 tmp
= TREE_TYPE (tmp
);
3638 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3640 /* Print variable's name. */
3642 dump_generic_node (pp
, t
, spc
, flags
, false);
3644 /* Print the dimensions. */
3645 tmp
= TREE_TYPE (t
);
3646 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3648 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3649 tmp
= TREE_TYPE (tmp
);
3652 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3654 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3656 dump_decl_name (pp
, t
, flags
);
3657 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3661 /* Print type declaration. */
3662 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3664 /* Print variable's name. */
3666 dump_generic_node (pp
, t
, spc
, flags
, false);
3669 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
3671 pp_string (pp
, " __asm__ ");
3673 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3674 pp_right_paren (pp
);
3677 /* The initial value of a function serves to determine whether the function
3678 is declared or defined. So the following does not apply to function
3680 if (TREE_CODE (t
) != FUNCTION_DECL
)
3682 /* Print the initial value. */
3683 if (DECL_INITIAL (t
))
3688 if (!(flags
& TDF_SLIM
))
3689 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3691 pp_string (pp
, "<<< omitted >>>");
3695 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3697 pp_string (pp
, " [value-expr: ");
3698 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3699 pp_right_bracket (pp
);
3706 /* Prints a structure: name, fields, and methods.
3707 FIXME: Still incomplete. */
3710 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
3713 /* Print the name of the structure. */
3714 if (TYPE_NAME (node
))
3717 if (TREE_CODE (node
) == RECORD_TYPE
)
3718 pp_string (pp
, "struct ");
3719 else if ((TREE_CODE (node
) == UNION_TYPE
3720 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3721 pp_string (pp
, "union ");
3723 dump_generic_node (pp
, TYPE_NAME (node
), spc
, TDF_NONE
, false);
3726 /* Print the contents of the structure. */
3732 /* Print the fields of the structure. */
3735 tmp
= TYPE_FIELDS (node
);
3738 /* Avoid to print recursively the structure. */
3739 /* FIXME : Not implemented correctly...,
3740 what about the case when we have a cycle in the contain graph? ...
3741 Maybe this could be solved by looking at the scope in which the
3742 structure was declared. */
3743 if (TREE_TYPE (tmp
) != node
3744 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3745 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3747 print_declaration (pp
, tmp
, spc
+2, flags
);
3750 tmp
= DECL_CHAIN (tmp
);
3754 pp_right_brace (pp
);
3757 /* Return the priority of the operator CODE.
3759 From lowest to highest precedence with either left-to-right (L-R)
3760 or right-to-left (R-L) associativity]:
3763 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3775 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3776 15 [L-R] fn() [] -> .
3778 unary +, - and * have higher precedence than the corresponding binary
3782 op_code_prio (enum tree_code code
)
3799 case TRUTH_ORIF_EXPR
:
3802 case TRUTH_AND_EXPR
:
3803 case TRUTH_ANDIF_EXPR
:
3810 case TRUTH_XOR_EXPR
:
3827 case UNORDERED_EXPR
:
3838 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3839 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3840 case WIDEN_LSHIFT_EXPR
:
3843 case WIDEN_SUM_EXPR
:
3845 case POINTER_PLUS_EXPR
:
3846 case POINTER_DIFF_EXPR
:
3850 case VEC_WIDEN_MULT_HI_EXPR
:
3851 case VEC_WIDEN_MULT_LO_EXPR
:
3852 case WIDEN_MULT_EXPR
:
3854 case WIDEN_MULT_PLUS_EXPR
:
3855 case WIDEN_MULT_MINUS_EXPR
:
3857 case MULT_HIGHPART_EXPR
:
3858 case TRUNC_DIV_EXPR
:
3860 case FLOOR_DIV_EXPR
:
3861 case ROUND_DIV_EXPR
:
3863 case EXACT_DIV_EXPR
:
3864 case TRUNC_MOD_EXPR
:
3866 case FLOOR_MOD_EXPR
:
3867 case ROUND_MOD_EXPR
:
3870 case TRUTH_NOT_EXPR
:
3872 case POSTINCREMENT_EXPR
:
3873 case POSTDECREMENT_EXPR
:
3874 case PREINCREMENT_EXPR
:
3875 case PREDECREMENT_EXPR
:
3881 case FIX_TRUNC_EXPR
:
3887 case ARRAY_RANGE_REF
:
3891 /* Special expressions. */
3897 case VEC_UNPACK_HI_EXPR
:
3898 case VEC_UNPACK_LO_EXPR
:
3899 case VEC_UNPACK_FLOAT_HI_EXPR
:
3900 case VEC_UNPACK_FLOAT_LO_EXPR
:
3901 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3902 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3903 case VEC_PACK_TRUNC_EXPR
:
3904 case VEC_PACK_SAT_EXPR
:
3908 /* Return an arbitrarily high precedence to avoid surrounding single
3909 VAR_DECLs in ()s. */
3914 /* Return the priority of the operator OP. */
3917 op_prio (const_tree op
)
3919 enum tree_code code
;
3924 code
= TREE_CODE (op
);
3925 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3926 return op_prio (TREE_OPERAND (op
, 0));
3928 return op_code_prio (code
);
3931 /* Return the symbol associated with operator CODE. */
3934 op_symbol_code (enum tree_code code
)
3942 case TRUTH_ORIF_EXPR
:
3945 case TRUTH_AND_EXPR
:
3946 case TRUTH_ANDIF_EXPR
:
3952 case TRUTH_XOR_EXPR
:
3962 case UNORDERED_EXPR
:
4008 case WIDEN_LSHIFT_EXPR
:
4011 case POINTER_PLUS_EXPR
:
4017 case WIDEN_SUM_EXPR
:
4020 case WIDEN_MULT_EXPR
:
4023 case MULT_HIGHPART_EXPR
:
4028 case POINTER_DIFF_EXPR
:
4034 case TRUTH_NOT_EXPR
:
4041 case TRUNC_DIV_EXPR
:
4048 case FLOOR_DIV_EXPR
:
4051 case ROUND_DIV_EXPR
:
4054 case EXACT_DIV_EXPR
:
4057 case TRUNC_MOD_EXPR
:
4063 case FLOOR_MOD_EXPR
:
4066 case ROUND_MOD_EXPR
:
4069 case PREDECREMENT_EXPR
:
4072 case PREINCREMENT_EXPR
:
4075 case POSTDECREMENT_EXPR
:
4078 case POSTINCREMENT_EXPR
:
4088 return "<<< ??? >>>";
4092 /* Return the symbol associated with operator OP. */
4095 op_symbol (const_tree op
)
4097 return op_symbol_code (TREE_CODE (op
));
4100 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
4101 the gimple_call_fn of a GIMPLE_CALL. */
4104 print_call_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
4108 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
4109 op0
= TREE_OPERAND (op0
, 0);
4112 switch (TREE_CODE (op0
))
4117 dump_function_name (pp
, op0
, flags
);
4123 op0
= TREE_OPERAND (op0
, 0);
4128 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
4129 pp_string (pp
, ") ? ");
4130 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
4131 pp_string (pp
, " : ");
4132 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
4136 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
4137 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
4139 dump_generic_node (pp
, op0
, 0, flags
, false);
4143 if (integer_zerop (TREE_OPERAND (op0
, 1)))
4145 op0
= TREE_OPERAND (op0
, 0);
4152 dump_generic_node (pp
, op0
, 0, flags
, false);
4160 /* Print the first N characters in the array STR, replacing non-printable
4161 characters (including embedded nuls) with unambiguous escape sequences. */
4164 pretty_print_string (pretty_printer
*pp
, const char *str
, unsigned n
)
4169 for ( ; n
; --n
, ++str
)
4174 pp_string (pp
, "\\b");
4178 pp_string (pp
, "\\f");
4182 pp_string (pp
, "\\n");
4186 pp_string (pp
, "\\r");
4190 pp_string (pp
, "\\t");
4194 pp_string (pp
, "\\v");
4198 pp_string (pp
, "\\\\");
4202 pp_string (pp
, "\\\"");
4206 pp_string (pp
, "\\'");
4210 if (str
[0] || n
> 1)
4212 if (!ISPRINT (str
[0]))
4215 sprintf (buf
, "\\x%02x", (unsigned char)str
[0]);
4216 pp_string (pp
, buf
);
4219 pp_character (pp
, str
[0]);
4227 maybe_init_pretty_print (FILE *file
)
4231 tree_pp
= new pretty_printer ();
4232 pp_needs_newline (tree_pp
) = true;
4233 pp_translate_identifiers (tree_pp
) = false;
4236 tree_pp
->buffer
->stream
= file
;
4240 newline_and_indent (pretty_printer
*pp
, int spc
)
4246 /* Handle the %K format for TEXT. Separate from default_tree_printer
4247 so it can also be used in front ends.
4248 The location LOC and BLOCK are expected to be extracted by the caller
4249 from the %K argument arg via EXPR_LOCATION(arg) and TREE_BLOCK(arg). */
4252 percent_K_format (text_info
*text
, location_t loc
, tree block
)
4254 text
->set_location (0, loc
, SHOW_RANGE_WITH_CARET
);
4255 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
4256 *pp_ti_abstract_origin (text
) = NULL
;
4259 && TREE_CODE (block
) == BLOCK
4260 && BLOCK_ABSTRACT_ORIGIN (block
))
4262 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
4263 if (TREE_CODE (ao
) == FUNCTION_DECL
)
4265 *pp_ti_abstract_origin (text
) = block
;
4268 block
= BLOCK_SUPERCONTEXT (block
);
4272 /* Print the identifier ID to PRETTY-PRINTER. */
4275 pp_tree_identifier (pretty_printer
*pp
, tree id
)
4277 if (pp_translate_identifiers (pp
))
4279 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
4280 pp_append_text (pp
, text
, text
+ strlen (text
));
4283 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
4284 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
4287 /* A helper function that is used to dump function information before the
4291 dump_function_header (FILE *dump_file
, tree fdecl
, dump_flags_t flags
)
4293 const char *dname
, *aname
;
4294 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
4295 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
4297 dname
= lang_hooks
.decl_printable_name (fdecl
, 1);
4299 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
4300 aname
= (IDENTIFIER_POINTER
4301 (DECL_ASSEMBLER_NAME (fdecl
)));
4303 aname
= "<unset-asm-name>";
4305 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
4306 dname
, aname
, fun
->funcdef_no
);
4307 if (!(flags
& TDF_NOUID
))
4308 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
4311 fprintf (dump_file
, ", cgraph_uid=%d", node
->get_uid ());
4312 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
4313 node
->frequency
== NODE_FREQUENCY_HOT
4315 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
4316 ? " (unlikely executed)"
4317 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
4318 ? " (executed once)"
4322 fprintf (dump_file
, ")\n\n");
4325 /* Dump double_int D to pretty_printer PP. UNS is true
4326 if D is unsigned and false otherwise. */
4328 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4331 pp_wide_integer (pp
, d
.low
);
4332 else if (d
.fits_uhwi ())
4333 pp_unsigned_wide_integer (pp
, d
.low
);
4336 unsigned HOST_WIDE_INT low
= d
.low
;
4337 HOST_WIDE_INT high
= d
.high
;
4338 if (!uns
&& d
.is_negative ())
4341 high
= ~high
+ !low
;
4344 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4346 sprintf (pp_buffer (pp
)->digit_buffer
,
4347 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4348 (unsigned HOST_WIDE_INT
) high
, low
);
4349 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
4354 # pragma GCC diagnostic pop