1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2021 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 /* Routines in this file get invoked via the default tree printer
40 used by diagnostics and thus they are called from pp_printf which
41 isn't reentrant. Avoid using pp_printf in this file. */
42 #pragma GCC poison pp_printf
44 /* Disable warnings about quoting issues in the pp_xxx calls below
45 that (intentionally) don't follow GCC diagnostic conventions. */
47 # pragma GCC diagnostic push
48 # pragma GCC diagnostic ignored "-Wformat-diag"
51 /* Local functions, macros and variables. */
52 static const char *op_symbol (const_tree
);
53 static void newline_and_indent (pretty_printer
*, int);
54 static void maybe_init_pretty_print (FILE *);
55 static void print_struct_decl (pretty_printer
*, const_tree
, int, dump_flags_t
);
56 static void do_niy (pretty_printer
*, const_tree
, dump_flags_t
);
58 #define INDENT(SPACE) do { \
59 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
61 #define NIY do_niy (pp, node, flags)
63 static pretty_printer
*tree_pp
;
65 /* Try to print something for an unknown tree code. */
68 do_niy (pretty_printer
*pp
, const_tree node
, dump_flags_t flags
)
72 pp_string (pp
, "<<< Unknown tree: ");
73 pp_string (pp
, get_tree_code_name (TREE_CODE (node
)));
77 len
= TREE_OPERAND_LENGTH (node
);
78 for (i
= 0; i
< len
; ++i
)
80 newline_and_indent (pp
, 2);
81 dump_generic_node (pp
, TREE_OPERAND (node
, i
), 2, flags
, false);
85 pp_string (pp
, " >>>");
88 /* Debugging function to print out a generic expression. */
91 debug_generic_expr (tree t
)
93 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
94 fprintf (stderr
, "\n");
97 /* Debugging function to print out a generic statement. */
100 debug_generic_stmt (tree t
)
102 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
103 fprintf (stderr
, "\n");
106 /* Debugging function to print out a chain of trees . */
109 debug_tree_chain (tree t
)
115 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
116 fprintf (stderr
, " ");
120 fprintf (stderr
, "... [cycled back to ");
121 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
122 fprintf (stderr
, "]");
126 fprintf (stderr
, "\n");
129 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
131 print_generic_decl (FILE *file
, tree decl
, dump_flags_t flags
)
133 maybe_init_pretty_print (file
);
134 print_declaration (tree_pp
, decl
, 2, flags
);
135 pp_write_text_to_stream (tree_pp
);
138 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
139 to show in the dump. See TDF_* in dumpfile.h. */
142 print_generic_stmt (FILE *file
, tree t
, dump_flags_t flags
)
144 maybe_init_pretty_print (file
);
145 dump_generic_node (tree_pp
, t
, 0, flags
, true);
146 pp_newline_and_flush (tree_pp
);
149 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
150 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
154 print_generic_stmt_indented (FILE *file
, tree t
, dump_flags_t flags
, int indent
)
158 maybe_init_pretty_print (file
);
160 for (i
= 0; i
< indent
; i
++)
162 dump_generic_node (tree_pp
, t
, indent
, flags
, true);
163 pp_newline_and_flush (tree_pp
);
166 /* Print a single expression T on file FILE. FLAGS specifies details to show
167 in the dump. See TDF_* in dumpfile.h. */
170 print_generic_expr (FILE *file
, tree t
, dump_flags_t flags
)
172 maybe_init_pretty_print (file
);
173 dump_generic_node (tree_pp
, t
, 0, flags
, false);
177 /* Print a single expression T to string, and return it. The caller
178 must free the returned memory. */
181 print_generic_expr_to_str (tree t
)
184 dump_generic_node (&pp
, t
, 0, TDF_VOPS
|TDF_MEMSYMS
, false);
185 return xstrdup (pp_formatted_text (&pp
));
188 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
189 in it are replaced with Dxxxx, as long as they are at the start or
190 preceded by $ and at the end or followed by $. See make_fancy_name
194 dump_fancy_name (pretty_printer
*pp
, tree name
)
197 int length
= IDENTIFIER_LENGTH (name
);
198 const char *n
= IDENTIFIER_POINTER (name
);
205 && (n
== IDENTIFIER_POINTER (name
) || n
[-1] == '$'))
208 while (ISDIGIT (n
[l
]))
210 if (n
[l
] == '\0' || n
[l
] == '$')
223 pp_tree_identifier (pp
, name
);
227 char *str
= XNEWVEC (char, length
+ 1);
230 q
= n
= IDENTIFIER_POINTER (name
);
237 && (q
== IDENTIFIER_POINTER (name
) || q
[-1] == '$'))
240 while (ISDIGIT (q
[l
]))
242 if (q
[l
] == '\0' || q
[l
] == '$')
244 memcpy (p
, n
, q
- n
);
245 memcpy (p
+ (q
- n
), "Dxxxx", 5);
255 memcpy (p
, n
, IDENTIFIER_LENGTH (name
) - (n
- IDENTIFIER_POINTER (name
)));
257 if (pp_translate_identifiers (pp
))
259 const char *text
= identifier_to_locale (str
);
260 pp_append_text (pp
, text
, text
+ strlen (text
));
263 pp_append_text (pp
, str
, str
+ length
);
267 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
271 dump_decl_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
273 tree name
= DECL_NAME (node
);
276 if ((flags
& TDF_ASMNAME
)
277 && HAS_DECL_ASSEMBLER_NAME_P (node
)
278 && DECL_ASSEMBLER_NAME_SET_P (node
))
279 pp_tree_identifier (pp
, DECL_ASSEMBLER_NAME_RAW (node
));
280 /* For -fcompare-debug don't dump DECL_NAMELESS names at all,
281 -g might have created more fancy names and their indexes
282 could get out of sync. Usually those should be DECL_IGNORED_P
283 too, SRA can create even non-DECL_IGNORED_P DECL_NAMELESS fancy
284 names, let's hope those never get out of sync after doing the
285 dump_fancy_name sanitization. */
286 else if ((flags
& TDF_COMPARE_DEBUG
)
287 && DECL_NAMELESS (node
)
288 && DECL_IGNORED_P (node
))
290 /* For DECL_NAMELESS names look for embedded uids in the
291 names and sanitize them for TDF_NOUID. */
292 else if ((flags
& TDF_NOUID
) && DECL_NAMELESS (node
))
293 dump_fancy_name (pp
, name
);
295 pp_tree_identifier (pp
, name
);
297 char uid_sep
= (flags
& TDF_GIMPLE
) ? '_' : '.';
298 if ((flags
& TDF_UID
) || name
== NULL_TREE
)
300 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
302 pp_character (pp
, 'L');
303 pp_character (pp
, uid_sep
);
304 pp_decimal_int (pp
, (int) LABEL_DECL_UID (node
));
306 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
308 if (flags
& TDF_NOUID
)
309 pp_string (pp
, "D#xxxx");
312 pp_string (pp
, "D#");
313 pp_decimal_int (pp
, (int) DEBUG_TEMP_UID (node
));
318 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
319 pp_character (pp
, c
);
320 pp_character (pp
, uid_sep
);
321 if (flags
& TDF_NOUID
)
322 pp_string (pp
, "xxxx");
324 pp_scalar (pp
, "%u", DECL_UID (node
));
327 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
329 if (flags
& TDF_NOUID
)
330 pp_string (pp
, "ptD.xxxx");
333 pp_string (pp
, "ptD.");
334 pp_scalar (pp
, "%u", DECL_PT_UID (node
));
339 /* Like the above, but used for pretty printing function calls. */
342 dump_function_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
344 if (CONVERT_EXPR_P (node
))
345 node
= TREE_OPERAND (node
, 0);
346 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
347 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
349 dump_decl_name (pp
, node
, flags
);
352 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
353 FLAGS are as in dump_generic_node. */
356 dump_function_declaration (pretty_printer
*pp
, tree node
,
357 int spc
, dump_flags_t flags
)
359 bool wrote_arg
= false;
365 /* Print the argument types. */
366 arg
= TYPE_ARG_TYPES (node
);
367 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
375 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
376 arg
= TREE_CHAIN (arg
);
379 /* Drop the trailing void_type_node if we had any previous argument. */
380 if (arg
== void_list_node
&& !wrote_arg
)
381 pp_string (pp
, "void");
382 /* Properly dump vararg function types. */
383 else if (!arg
&& wrote_arg
)
384 pp_string (pp
, ", ...");
385 /* Avoid printing any arg for unprototyped functions. */
390 /* Dump the domain associated with an array. */
393 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, dump_flags_t flags
)
395 pp_left_bracket (pp
);
398 tree min
= TYPE_MIN_VALUE (domain
);
399 tree max
= TYPE_MAX_VALUE (domain
);
402 && integer_zerop (min
)
403 && tree_fits_shwi_p (max
))
404 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
408 dump_generic_node (pp
, min
, spc
, flags
, false);
411 dump_generic_node (pp
, max
, spc
, flags
, false);
415 pp_string (pp
, "<unknown>");
416 pp_right_bracket (pp
);
420 /* Dump OpenMP iterators ITER. */
423 dump_omp_iterators (pretty_printer
*pp
, tree iter
, int spc
, dump_flags_t flags
)
425 pp_string (pp
, "iterator(");
426 for (tree it
= iter
; it
; it
= TREE_CHAIN (it
))
429 pp_string (pp
, ", ");
430 dump_generic_node (pp
, TREE_TYPE (TREE_VEC_ELT (it
, 0)), spc
, flags
,
433 dump_generic_node (pp
, TREE_VEC_ELT (it
, 0), spc
, flags
, false);
435 dump_generic_node (pp
, TREE_VEC_ELT (it
, 1), spc
, flags
, false);
437 dump_generic_node (pp
, TREE_VEC_ELT (it
, 2), spc
, flags
, false);
439 dump_generic_node (pp
, TREE_VEC_ELT (it
, 3), spc
, flags
, false);
445 /* Dump OMP clause CLAUSE, without following OMP_CLAUSE_CHAIN.
447 PP, CLAUSE, SPC and FLAGS are as in dump_generic_node. */
450 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
453 const char *modifier
= NULL
;
454 switch (OMP_CLAUSE_CODE (clause
))
456 case OMP_CLAUSE_PRIVATE
:
459 case OMP_CLAUSE_SHARED
:
462 case OMP_CLAUSE_FIRSTPRIVATE
:
463 name
= "firstprivate";
465 case OMP_CLAUSE_LASTPRIVATE
:
466 name
= "lastprivate";
467 if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clause
))
468 modifier
= "conditional:";
470 case OMP_CLAUSE_COPYIN
:
473 case OMP_CLAUSE_COPYPRIVATE
:
474 name
= "copyprivate";
476 case OMP_CLAUSE_UNIFORM
:
479 case OMP_CLAUSE_USE_DEVICE_PTR
:
480 name
= "use_device_ptr";
481 if (OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT (clause
))
482 modifier
= "if_present:";
484 case OMP_CLAUSE_USE_DEVICE_ADDR
:
485 name
= "use_device_addr";
487 case OMP_CLAUSE_IS_DEVICE_PTR
:
488 name
= "is_device_ptr";
490 case OMP_CLAUSE_INCLUSIVE
:
493 case OMP_CLAUSE_EXCLUSIVE
:
496 case OMP_CLAUSE__LOOPTEMP_
:
499 case OMP_CLAUSE__REDUCTEMP_
:
500 name
= "_reductemp_";
502 case OMP_CLAUSE__CONDTEMP_
:
505 case OMP_CLAUSE__SCANTEMP_
:
508 case OMP_CLAUSE_TO_DECLARE
:
511 case OMP_CLAUSE_LINK
:
514 case OMP_CLAUSE_NONTEMPORAL
:
515 name
= "nontemporal";
518 pp_string (pp
, name
);
521 pp_string (pp
, modifier
);
522 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
527 case OMP_CLAUSE_TASK_REDUCTION
:
528 case OMP_CLAUSE_IN_REDUCTION
:
529 pp_string (pp
, OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_IN_REDUCTION
532 case OMP_CLAUSE_REDUCTION
:
533 pp_string (pp
, "reduction(");
534 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_REDUCTION
)
536 if (OMP_CLAUSE_REDUCTION_TASK (clause
))
537 pp_string (pp
, "task,");
538 else if (OMP_CLAUSE_REDUCTION_INSCAN (clause
))
539 pp_string (pp
, "inscan,");
541 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
544 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
547 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
553 pp_string (pp
, "if(");
554 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
556 case ERROR_MARK
: break;
557 case VOID_CST
: pp_string (pp
, "cancel:"); break;
558 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
559 case OMP_SIMD
: pp_string (pp
, "simd:"); break;
560 case OMP_TASK
: pp_string (pp
, "task:"); break;
561 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
562 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
563 case OMP_TARGET
: pp_string (pp
, "target:"); break;
564 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
565 case OMP_TARGET_ENTER_DATA
:
566 pp_string (pp
, "target enter data:"); break;
567 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
568 default: gcc_unreachable ();
570 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
575 case OMP_CLAUSE_NUM_THREADS
:
576 pp_string (pp
, "num_threads(");
577 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
582 case OMP_CLAUSE_NOWAIT
:
583 pp_string (pp
, "nowait");
585 case OMP_CLAUSE_ORDERED
:
586 pp_string (pp
, "ordered");
587 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
590 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
596 case OMP_CLAUSE_DEFAULT
:
597 pp_string (pp
, "default(");
598 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
600 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
602 case OMP_CLAUSE_DEFAULT_SHARED
:
603 pp_string (pp
, "shared");
605 case OMP_CLAUSE_DEFAULT_NONE
:
606 pp_string (pp
, "none");
608 case OMP_CLAUSE_DEFAULT_PRIVATE
:
609 pp_string (pp
, "private");
611 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
612 pp_string (pp
, "firstprivate");
614 case OMP_CLAUSE_DEFAULT_PRESENT
:
615 pp_string (pp
, "present");
623 case OMP_CLAUSE_SCHEDULE
:
624 pp_string (pp
, "schedule(");
625 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
626 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
627 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
629 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
630 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
631 pp_string (pp
, "monotonic");
633 pp_string (pp
, "nonmonotonic");
634 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
639 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
640 pp_string (pp
, "simd:");
642 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
644 case OMP_CLAUSE_SCHEDULE_STATIC
:
645 pp_string (pp
, "static");
647 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
648 pp_string (pp
, "dynamic");
650 case OMP_CLAUSE_SCHEDULE_GUIDED
:
651 pp_string (pp
, "guided");
653 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
654 pp_string (pp
, "runtime");
656 case OMP_CLAUSE_SCHEDULE_AUTO
:
657 pp_string (pp
, "auto");
662 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
665 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
671 case OMP_CLAUSE_UNTIED
:
672 pp_string (pp
, "untied");
675 case OMP_CLAUSE_COLLAPSE
:
676 pp_string (pp
, "collapse(");
677 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
682 case OMP_CLAUSE_FINAL
:
683 pp_string (pp
, "final(");
684 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
689 case OMP_CLAUSE_MERGEABLE
:
690 pp_string (pp
, "mergeable");
693 case OMP_CLAUSE_LINEAR
:
694 pp_string (pp
, "linear(");
695 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
697 case OMP_CLAUSE_LINEAR_DEFAULT
:
699 case OMP_CLAUSE_LINEAR_REF
:
700 pp_string (pp
, "ref(");
702 case OMP_CLAUSE_LINEAR_VAL
:
703 pp_string (pp
, "val(");
705 case OMP_CLAUSE_LINEAR_UVAL
:
706 pp_string (pp
, "uval(");
711 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
713 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
716 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
721 case OMP_CLAUSE_ALIGNED
:
722 pp_string (pp
, "aligned(");
723 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
725 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
728 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
734 case OMP_CLAUSE_ALLOCATE
:
735 pp_string (pp
, "allocate(");
736 if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause
))
738 dump_generic_node (pp
, OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause
),
742 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
747 case OMP_CLAUSE_AFFINITY
:
748 pp_string (pp
, "affinity(");
750 tree t
= OMP_CLAUSE_DECL (clause
);
751 if (TREE_CODE (t
) == TREE_LIST
753 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
755 dump_omp_iterators (pp
, TREE_PURPOSE (t
), spc
, flags
);
759 dump_generic_node (pp
, t
, spc
, flags
, false);
763 case OMP_CLAUSE_DEPEND
:
764 pp_string (pp
, "depend(");
765 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
767 case OMP_CLAUSE_DEPEND_DEPOBJ
:
770 case OMP_CLAUSE_DEPEND_IN
:
773 case OMP_CLAUSE_DEPEND_OUT
:
776 case OMP_CLAUSE_DEPEND_INOUT
:
779 case OMP_CLAUSE_DEPEND_MUTEXINOUTSET
:
780 name
= "mutexinoutset";
782 case OMP_CLAUSE_DEPEND_SOURCE
:
783 pp_string (pp
, "source)");
785 case OMP_CLAUSE_DEPEND_LAST
:
786 name
= "__internal__";
788 case OMP_CLAUSE_DEPEND_SINK
:
789 pp_string (pp
, "sink:");
790 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
791 if (TREE_CODE (t
) == TREE_LIST
)
793 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
794 if (TREE_PURPOSE (t
) != integer_zero_node
)
796 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
800 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
814 tree t
= OMP_CLAUSE_DECL (clause
);
815 if (TREE_CODE (t
) == TREE_LIST
817 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
819 dump_omp_iterators (pp
, TREE_PURPOSE (t
), spc
, flags
);
825 pp_string (pp
, name
);
828 dump_generic_node (pp
, t
, spc
, flags
, false);
834 pp_string (pp
, "map(");
835 switch (OMP_CLAUSE_MAP_KIND (clause
))
838 case GOMP_MAP_POINTER
:
839 pp_string (pp
, "alloc");
841 case GOMP_MAP_IF_PRESENT
:
842 pp_string (pp
, "no_alloc");
845 case GOMP_MAP_TO_PSET
:
846 pp_string (pp
, "to");
849 pp_string (pp
, "from");
851 case GOMP_MAP_TOFROM
:
852 pp_string (pp
, "tofrom");
854 case GOMP_MAP_FORCE_ALLOC
:
855 pp_string (pp
, "force_alloc");
857 case GOMP_MAP_FORCE_TO
:
858 pp_string (pp
, "force_to");
860 case GOMP_MAP_FORCE_FROM
:
861 pp_string (pp
, "force_from");
863 case GOMP_MAP_FORCE_TOFROM
:
864 pp_string (pp
, "force_tofrom");
866 case GOMP_MAP_FORCE_PRESENT
:
867 pp_string (pp
, "force_present");
869 case GOMP_MAP_DELETE
:
870 pp_string (pp
, "delete");
872 case GOMP_MAP_FORCE_DEVICEPTR
:
873 pp_string (pp
, "force_deviceptr");
875 case GOMP_MAP_ALWAYS_TO
:
876 pp_string (pp
, "always,to");
878 case GOMP_MAP_ALWAYS_FROM
:
879 pp_string (pp
, "always,from");
881 case GOMP_MAP_ALWAYS_TOFROM
:
882 pp_string (pp
, "always,tofrom");
884 case GOMP_MAP_RELEASE
:
885 pp_string (pp
, "release");
887 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
888 pp_string (pp
, "firstprivate");
890 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
891 pp_string (pp
, "firstprivate ref");
893 case GOMP_MAP_STRUCT
:
894 pp_string (pp
, "struct");
896 case GOMP_MAP_ALWAYS_POINTER
:
897 pp_string (pp
, "always_pointer");
899 case GOMP_MAP_DEVICE_RESIDENT
:
900 pp_string (pp
, "device_resident");
903 pp_string (pp
, "link");
905 case GOMP_MAP_ATTACH
:
906 pp_string (pp
, "attach");
908 case GOMP_MAP_DETACH
:
909 pp_string (pp
, "detach");
911 case GOMP_MAP_FORCE_DETACH
:
912 pp_string (pp
, "force_detach");
914 case GOMP_MAP_ATTACH_DETACH
:
915 pp_string (pp
, "attach_detach");
921 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
924 if (OMP_CLAUSE_SIZE (clause
))
926 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
927 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
929 case GOMP_MAP_POINTER
:
930 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
931 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
932 case GOMP_MAP_ALWAYS_POINTER
:
933 pp_string (pp
, " [pointer assign, bias: ");
935 case GOMP_MAP_TO_PSET
:
936 pp_string (pp
, " [pointer set, len: ");
938 case GOMP_MAP_ATTACH
:
939 case GOMP_MAP_DETACH
:
940 case GOMP_MAP_FORCE_DETACH
:
941 case GOMP_MAP_ATTACH_DETACH
:
942 pp_string (pp
, " [bias: ");
945 pp_string (pp
, " [len: ");
948 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
950 pp_right_bracket (pp
);
955 case OMP_CLAUSE_FROM
:
956 pp_string (pp
, "from(");
957 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
959 goto print_clause_size
;
962 pp_string (pp
, "to(");
963 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
965 goto print_clause_size
;
967 case OMP_CLAUSE__CACHE_
:
969 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
971 goto print_clause_size
;
973 case OMP_CLAUSE_NUM_TEAMS
:
974 pp_string (pp
, "num_teams(");
975 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
980 case OMP_CLAUSE_THREAD_LIMIT
:
981 pp_string (pp
, "thread_limit(");
982 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
987 case OMP_CLAUSE_DEVICE
:
988 pp_string (pp
, "device(");
989 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
994 case OMP_CLAUSE_DIST_SCHEDULE
:
995 pp_string (pp
, "dist_schedule(static");
996 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
999 dump_generic_node (pp
,
1000 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
1003 pp_right_paren (pp
);
1006 case OMP_CLAUSE_PROC_BIND
:
1007 pp_string (pp
, "proc_bind(");
1008 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
1010 case OMP_CLAUSE_PROC_BIND_MASTER
:
1011 /* Same enum value: case OMP_CLAUSE_PROC_BIND_PRIMARY: */
1012 /* TODO: Change to 'primary' for OpenMP 5.1. */
1013 pp_string (pp
, "master");
1015 case OMP_CLAUSE_PROC_BIND_CLOSE
:
1016 pp_string (pp
, "close");
1018 case OMP_CLAUSE_PROC_BIND_SPREAD
:
1019 pp_string (pp
, "spread");
1024 pp_right_paren (pp
);
1027 case OMP_CLAUSE_DEVICE_TYPE
:
1028 pp_string (pp
, "device_type(");
1029 switch (OMP_CLAUSE_DEVICE_TYPE_KIND (clause
))
1031 case OMP_CLAUSE_DEVICE_TYPE_HOST
:
1032 pp_string (pp
, "host");
1034 case OMP_CLAUSE_DEVICE_TYPE_NOHOST
:
1035 pp_string (pp
, "nohost");
1037 case OMP_CLAUSE_DEVICE_TYPE_ANY
:
1038 pp_string (pp
, "any");
1043 pp_right_paren (pp
);
1046 case OMP_CLAUSE_SAFELEN
:
1047 pp_string (pp
, "safelen(");
1048 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
1050 pp_right_paren (pp
);
1053 case OMP_CLAUSE_SIMDLEN
:
1054 pp_string (pp
, "simdlen(");
1055 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
1057 pp_right_paren (pp
);
1060 case OMP_CLAUSE_PRIORITY
:
1061 pp_string (pp
, "priority(");
1062 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
1064 pp_right_paren (pp
);
1067 case OMP_CLAUSE_GRAINSIZE
:
1068 pp_string (pp
, "grainsize(");
1069 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
1071 pp_right_paren (pp
);
1074 case OMP_CLAUSE_NUM_TASKS
:
1075 pp_string (pp
, "num_tasks(");
1076 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
1078 pp_right_paren (pp
);
1081 case OMP_CLAUSE_HINT
:
1082 pp_string (pp
, "hint(");
1083 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
1085 pp_right_paren (pp
);
1088 case OMP_CLAUSE_FILTER
:
1089 pp_string (pp
, "filter(");
1090 dump_generic_node (pp
, OMP_CLAUSE_FILTER_EXPR (clause
),
1092 pp_right_paren (pp
);
1095 case OMP_CLAUSE_DEFAULTMAP
:
1096 pp_string (pp
, "defaultmap(");
1097 switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (clause
))
1099 case OMP_CLAUSE_DEFAULTMAP_ALLOC
:
1100 pp_string (pp
, "alloc");
1102 case OMP_CLAUSE_DEFAULTMAP_TO
:
1103 pp_string (pp
, "to");
1105 case OMP_CLAUSE_DEFAULTMAP_FROM
:
1106 pp_string (pp
, "from");
1108 case OMP_CLAUSE_DEFAULTMAP_TOFROM
:
1109 pp_string (pp
, "tofrom");
1111 case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE
:
1112 pp_string (pp
, "firstprivate");
1114 case OMP_CLAUSE_DEFAULTMAP_NONE
:
1115 pp_string (pp
, "none");
1117 case OMP_CLAUSE_DEFAULTMAP_DEFAULT
:
1118 pp_string (pp
, "default");
1123 switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (clause
))
1125 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED
:
1127 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR
:
1128 pp_string (pp
, ":scalar");
1130 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE
:
1131 pp_string (pp
, ":aggregate");
1133 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE
:
1134 pp_string (pp
, ":allocatable");
1136 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER
:
1137 pp_string (pp
, ":pointer");
1142 pp_right_paren (pp
);
1145 case OMP_CLAUSE_ORDER
:
1146 pp_string (pp
, "order(concurrent)");
1149 case OMP_CLAUSE_BIND
:
1150 pp_string (pp
, "bind(");
1151 switch (OMP_CLAUSE_BIND_KIND (clause
))
1153 case OMP_CLAUSE_BIND_TEAMS
:
1154 pp_string (pp
, "teams");
1156 case OMP_CLAUSE_BIND_PARALLEL
:
1157 pp_string (pp
, "parallel");
1159 case OMP_CLAUSE_BIND_THREAD
:
1160 pp_string (pp
, "thread");
1165 pp_right_paren (pp
);
1168 case OMP_CLAUSE__SIMDUID_
:
1169 pp_string (pp
, "_simduid_(");
1170 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
1172 pp_right_paren (pp
);
1175 case OMP_CLAUSE__SIMT_
:
1176 pp_string (pp
, "_simt_");
1179 case OMP_CLAUSE_GANG
:
1180 pp_string (pp
, "gang");
1181 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
1183 pp_string (pp
, "(num: ");
1184 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
1187 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
1189 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
1193 pp_string (pp
, "static:");
1194 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
1195 == integer_minus_one_node
)
1196 pp_character (pp
, '*');
1198 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
1201 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
1202 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
1203 pp_right_paren (pp
);
1206 case OMP_CLAUSE_ASYNC
:
1207 pp_string (pp
, "async");
1208 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
1210 pp_character(pp
, '(');
1211 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
1213 pp_character(pp
, ')');
1217 case OMP_CLAUSE_AUTO
:
1218 case OMP_CLAUSE_SEQ
:
1219 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
1222 case OMP_CLAUSE_WAIT
:
1223 pp_string (pp
, "wait(");
1224 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
1226 pp_character(pp
, ')');
1229 case OMP_CLAUSE_WORKER
:
1230 pp_string (pp
, "worker");
1231 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
1234 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
1236 pp_right_paren (pp
);
1240 case OMP_CLAUSE_VECTOR
:
1241 pp_string (pp
, "vector");
1242 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
1245 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
1247 pp_right_paren (pp
);
1251 case OMP_CLAUSE_NUM_GANGS
:
1252 pp_string (pp
, "num_gangs(");
1253 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
1255 pp_character (pp
, ')');
1258 case OMP_CLAUSE_NUM_WORKERS
:
1259 pp_string (pp
, "num_workers(");
1260 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
1262 pp_character (pp
, ')');
1265 case OMP_CLAUSE_VECTOR_LENGTH
:
1266 pp_string (pp
, "vector_length(");
1267 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
1269 pp_character (pp
, ')');
1272 case OMP_CLAUSE_INBRANCH
:
1273 pp_string (pp
, "inbranch");
1275 case OMP_CLAUSE_NOTINBRANCH
:
1276 pp_string (pp
, "notinbranch");
1278 case OMP_CLAUSE_FOR
:
1279 pp_string (pp
, "for");
1281 case OMP_CLAUSE_PARALLEL
:
1282 pp_string (pp
, "parallel");
1284 case OMP_CLAUSE_SECTIONS
:
1285 pp_string (pp
, "sections");
1287 case OMP_CLAUSE_TASKGROUP
:
1288 pp_string (pp
, "taskgroup");
1290 case OMP_CLAUSE_NOGROUP
:
1291 pp_string (pp
, "nogroup");
1293 case OMP_CLAUSE_THREADS
:
1294 pp_string (pp
, "threads");
1296 case OMP_CLAUSE_SIMD
:
1297 pp_string (pp
, "simd");
1299 case OMP_CLAUSE_INDEPENDENT
:
1300 pp_string (pp
, "independent");
1302 case OMP_CLAUSE_TILE
:
1303 pp_string (pp
, "tile(");
1304 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1306 pp_right_paren (pp
);
1309 case OMP_CLAUSE_IF_PRESENT
:
1310 pp_string (pp
, "if_present");
1312 case OMP_CLAUSE_FINALIZE
:
1313 pp_string (pp
, "finalize");
1315 case OMP_CLAUSE_NOHOST
:
1316 pp_string (pp
, "nohost");
1318 case OMP_CLAUSE_DETACH
:
1319 pp_string (pp
, "detach(");
1320 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
), spc
, flags
,
1322 pp_right_paren (pp
);
1331 /* Dump chain of OMP clauses.
1333 PP, SPC and FLAGS are as in dump_generic_node. */
1336 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
,
1343 dump_omp_clause (pp
, clause
, spc
, flags
);
1344 leading_space
= true;
1346 clause
= OMP_CLAUSE_CHAIN (clause
);
1351 /* Dump location LOC to PP. */
1354 dump_location (pretty_printer
*pp
, location_t loc
)
1356 expanded_location xloc
= expand_location (loc
);
1358 pp_left_bracket (pp
);
1361 pp_string (pp
, xloc
.file
);
1362 pp_string (pp
, ":");
1364 pp_decimal_int (pp
, xloc
.line
);
1366 pp_decimal_int (pp
, xloc
.column
);
1367 pp_string (pp
, "] ");
1371 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1372 dump_generic_node. */
1375 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, dump_flags_t flags
)
1379 pp_string (pp
, "BLOCK #");
1380 pp_decimal_int (pp
, BLOCK_NUMBER (block
));
1381 pp_character (pp
, ' ');
1383 if (flags
& TDF_ADDRESS
)
1385 pp_character (pp
, '[');
1386 pp_scalar (pp
, "%p", (void *) block
);
1387 pp_string (pp
, "] ");
1390 if (TREE_ASM_WRITTEN (block
))
1391 pp_string (pp
, "[written] ");
1393 if (flags
& TDF_SLIM
)
1396 if (BLOCK_SOURCE_LOCATION (block
))
1397 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1399 newline_and_indent (pp
, spc
+ 2);
1401 if (BLOCK_SUPERCONTEXT (block
))
1403 pp_string (pp
, "SUPERCONTEXT: ");
1404 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1405 flags
| TDF_SLIM
, false);
1406 newline_and_indent (pp
, spc
+ 2);
1409 if (BLOCK_SUBBLOCKS (block
))
1411 pp_string (pp
, "SUBBLOCKS: ");
1412 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1414 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1417 newline_and_indent (pp
, spc
+ 2);
1420 if (BLOCK_CHAIN (block
))
1422 pp_string (pp
, "SIBLINGS: ");
1423 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1425 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1428 newline_and_indent (pp
, spc
+ 2);
1431 if (BLOCK_VARS (block
))
1433 pp_string (pp
, "VARS: ");
1434 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1436 dump_generic_node (pp
, t
, 0, flags
, false);
1439 newline_and_indent (pp
, spc
+ 2);
1442 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1445 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1447 pp_string (pp
, "NONLOCALIZED_VARS: ");
1448 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1450 dump_generic_node (pp
, t
, 0, flags
, false);
1453 newline_and_indent (pp
, spc
+ 2);
1456 if (BLOCK_ABSTRACT_ORIGIN (block
))
1458 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1459 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1460 flags
| TDF_SLIM
, false);
1461 newline_and_indent (pp
, spc
+ 2);
1464 if (BLOCK_FRAGMENT_ORIGIN (block
))
1466 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1467 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1468 flags
| TDF_SLIM
, false);
1469 newline_and_indent (pp
, spc
+ 2);
1472 if (BLOCK_FRAGMENT_CHAIN (block
))
1474 pp_string (pp
, "FRAGMENT_CHAIN: ");
1475 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1477 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1480 newline_and_indent (pp
, spc
+ 2);
1484 /* Dump #pragma omp atomic memory order clause. */
1487 dump_omp_atomic_memory_order (pretty_printer
*pp
, enum omp_memory_order mo
)
1491 case OMP_MEMORY_ORDER_RELAXED
:
1492 pp_string (pp
, " relaxed");
1494 case OMP_MEMORY_ORDER_SEQ_CST
:
1495 pp_string (pp
, " seq_cst");
1497 case OMP_MEMORY_ORDER_ACQ_REL
:
1498 pp_string (pp
, " acq_rel");
1500 case OMP_MEMORY_ORDER_ACQUIRE
:
1501 pp_string (pp
, " acquire");
1503 case OMP_MEMORY_ORDER_RELEASE
:
1504 pp_string (pp
, " release");
1506 case OMP_MEMORY_ORDER_UNSPECIFIED
:
1513 /* Helper to dump a MEM_REF node. */
1516 dump_mem_ref (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
)
1518 if (TREE_CODE (node
) == MEM_REF
&& (flags
& TDF_GIMPLE
))
1520 pp_string (pp
, "__MEM <");
1521 dump_generic_node (pp
, TREE_TYPE (node
),
1522 spc
, flags
| TDF_SLIM
, false);
1523 if (TYPE_ALIGN (TREE_TYPE (node
))
1524 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
1526 pp_string (pp
, ", ");
1527 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
1530 pp_string (pp
, " (");
1531 if (TREE_TYPE (TREE_OPERAND (node
, 0))
1532 != TREE_TYPE (TREE_OPERAND (node
, 1)))
1535 dump_generic_node (pp
, TREE_TYPE (TREE_OPERAND (node
, 1)),
1536 spc
, flags
| TDF_SLIM
, false);
1537 pp_right_paren (pp
);
1539 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1540 spc
, flags
| TDF_SLIM
, false);
1541 if (! integer_zerop (TREE_OPERAND (node
, 1)))
1543 pp_string (pp
, " + ");
1544 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1545 spc
, flags
| TDF_SLIM
, false);
1547 pp_right_paren (pp
);
1549 else if (TREE_CODE (node
) == MEM_REF
1550 && integer_zerop (TREE_OPERAND (node
, 1))
1551 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1552 infer them and MEM_ATTR caching will share MEM_REFs
1553 with differently-typed op0s. */
1554 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1555 /* Released SSA_NAMES have no TREE_TYPE. */
1556 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1557 /* Same pointer types, but ignoring POINTER_TYPE vs.
1559 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1560 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1561 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1562 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1563 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1564 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1565 /* Same value types ignoring qualifiers. */
1566 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1567 == TYPE_MAIN_VARIANT
1568 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1569 && (!(flags
& TDF_ALIAS
)
1570 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1572 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1574 /* Enclose pointers to arrays in parentheses. */
1575 tree op0
= TREE_OPERAND (node
, 0);
1576 tree op0type
= TREE_TYPE (op0
);
1577 if (POINTER_TYPE_P (op0type
)
1578 && TREE_CODE (TREE_TYPE (op0type
)) == ARRAY_TYPE
)
1581 dump_generic_node (pp
, op0
, spc
, flags
, false);
1582 if (POINTER_TYPE_P (op0type
)
1583 && TREE_CODE (TREE_TYPE (op0type
)) == ARRAY_TYPE
)
1584 pp_right_paren (pp
);
1587 dump_generic_node (pp
,
1588 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1593 pp_string (pp
, "MEM");
1595 tree nodetype
= TREE_TYPE (node
);
1596 tree op0
= TREE_OPERAND (node
, 0);
1597 tree op1
= TREE_OPERAND (node
, 1);
1598 tree op1type
= TYPE_MAIN_VARIANT (TREE_TYPE (op1
));
1600 tree op0size
= TYPE_SIZE (nodetype
);
1601 tree op1size
= TYPE_SIZE (TREE_TYPE (op1type
));
1603 if (!op0size
|| !op1size
1604 || !operand_equal_p (op0size
, op1size
, 0))
1606 pp_string (pp
, " <");
1607 /* If the size of the type of the operand is not the same
1608 as the size of the MEM_REF expression include the type
1609 of the latter similar to the TDF_GIMPLE output to make
1610 it clear how many bytes of memory are being accessed. */
1611 dump_generic_node (pp
, nodetype
, spc
, flags
| TDF_SLIM
, false);
1612 pp_string (pp
, "> ");
1615 pp_string (pp
, "[(");
1616 dump_generic_node (pp
, op1type
, spc
, flags
| TDF_SLIM
, false);
1617 pp_right_paren (pp
);
1618 dump_generic_node (pp
, op0
, spc
, flags
, false);
1619 if (!integer_zerop (op1
))
1621 pp_string (pp
, " + ");
1622 dump_generic_node (pp
, op1
, spc
, flags
, false);
1624 if (TREE_CODE (node
) == TARGET_MEM_REF
)
1626 tree tmp
= TMR_INDEX2 (node
);
1629 pp_string (pp
, " + ");
1630 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1632 tmp
= TMR_INDEX (node
);
1635 pp_string (pp
, " + ");
1636 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1637 tmp
= TMR_STEP (node
);
1638 pp_string (pp
, " * ");
1640 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1642 pp_string (pp
, "1");
1645 if ((flags
& TDF_ALIAS
)
1646 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1648 pp_string (pp
, " clique ");
1649 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1650 pp_string (pp
, " base ");
1651 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1653 pp_right_bracket (pp
);
1657 /* Helper function for dump_generic_node. Dump INIT or COND expression for
1658 OpenMP loop non-rectangular iterators. */
1661 dump_omp_loop_non_rect_expr (pretty_printer
*pp
, tree node
, int spc
,
1664 gcc_assert (TREE_CODE (node
) == TREE_VEC
);
1665 dump_generic_node (pp
, TREE_VEC_ELT (node
, 0), spc
, flags
, false);
1666 pp_string (pp
, " * ");
1667 if (op_prio (TREE_VEC_ELT (node
, 1)) <= op_code_prio (MULT_EXPR
))
1670 dump_generic_node (pp
, TREE_VEC_ELT (node
, 1), spc
, flags
, false);
1671 pp_right_paren (pp
);
1674 dump_generic_node (pp
, TREE_VEC_ELT (node
, 1), spc
, flags
, false);
1675 pp_string (pp
, " + ");
1676 if (op_prio (TREE_VEC_ELT (node
, 1)) <= op_code_prio (PLUS_EXPR
))
1679 dump_generic_node (pp
, TREE_VEC_ELT (node
, 2), spc
, flags
, false);
1680 pp_right_paren (pp
);
1683 dump_generic_node (pp
, TREE_VEC_ELT (node
, 2), spc
, flags
, false);
1686 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1687 indent. FLAGS specifies details to show in the dump (see TDF_* in
1688 dumpfile.h). If IS_STMT is true, the object printed is considered
1689 to be a statement and it is terminated by ';' if appropriate. */
1692 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
,
1699 enum tree_code code
;
1701 if (node
== NULL_TREE
)
1704 is_expr
= EXPR_P (node
);
1706 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1708 pp_string (pp
, "<&");
1709 pp_scalar (pp
, "%p", (void *)node
);
1710 pp_string (pp
, "> ");
1713 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1714 dump_location (pp
, EXPR_LOCATION (node
));
1716 code
= TREE_CODE (node
);
1720 pp_string (pp
, "<<< error >>>");
1723 case IDENTIFIER_NODE
:
1724 pp_tree_identifier (pp
, node
);
1728 while (node
&& node
!= error_mark_node
)
1730 if (TREE_PURPOSE (node
))
1732 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1735 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1736 node
= TREE_CHAIN (node
);
1737 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1746 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1752 if (TREE_VEC_LENGTH (node
) > 0)
1754 size_t len
= TREE_VEC_LENGTH (node
);
1755 for (i
= 0; i
< len
- 1; i
++)
1757 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1762 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1771 case FIXED_POINT_TYPE
:
1778 unsigned int quals
= TYPE_QUALS (node
);
1779 enum tree_code_class tclass
;
1781 if (quals
& TYPE_QUAL_ATOMIC
)
1782 pp_string (pp
, "atomic ");
1783 if (quals
& TYPE_QUAL_CONST
)
1784 pp_string (pp
, "const ");
1785 if (quals
& TYPE_QUAL_VOLATILE
)
1786 pp_string (pp
, "volatile ");
1787 if (quals
& TYPE_QUAL_RESTRICT
)
1788 pp_string (pp
, "restrict ");
1790 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1792 pp_string (pp
, "<address-space-");
1793 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1794 pp_string (pp
, "> ");
1797 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1799 if (tclass
== tcc_declaration
)
1801 if (DECL_NAME (node
))
1802 dump_decl_name (pp
, node
, flags
);
1804 pp_string (pp
, "<unnamed type decl>");
1806 else if (tclass
== tcc_type
)
1808 if (TYPE_NAME (node
))
1810 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1811 pp_tree_identifier (pp
, TYPE_NAME (node
));
1812 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1813 && DECL_NAME (TYPE_NAME (node
)))
1814 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1816 pp_string (pp
, "<unnamed type>");
1818 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1820 pp_string (pp
, "vector");
1822 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1823 pp_string (pp
, ") ");
1824 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1826 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1828 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1829 pp_string (pp
, (TYPE_UNSIGNED (node
)
1832 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1833 pp_string (pp
, (TYPE_UNSIGNED (node
)
1836 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1837 pp_string (pp
, (TYPE_UNSIGNED (node
)
1840 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1841 pp_string (pp
, (TYPE_UNSIGNED (node
)
1844 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1845 pp_string (pp
, (TYPE_UNSIGNED (node
)
1846 ? "unsigned long long"
1847 : "signed long long"));
1848 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1849 && pow2p_hwi (TYPE_PRECISION (node
)))
1851 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1852 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1853 pp_string (pp
, "_t");
1857 pp_string (pp
, (TYPE_UNSIGNED (node
)
1858 ? "<unnamed-unsigned:"
1859 : "<unnamed-signed:"));
1860 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1864 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1866 pp_string (pp
, "__complex__ ");
1867 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1869 else if (TREE_CODE (node
) == REAL_TYPE
)
1871 pp_string (pp
, "<float:");
1872 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1875 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1877 pp_string (pp
, "<fixed-point-");
1878 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1879 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1882 else if (TREE_CODE (node
) == BOOLEAN_TYPE
)
1884 pp_string (pp
, (TYPE_UNSIGNED (node
)
1885 ? "<unsigned-boolean:"
1886 : "<signed-boolean:"));
1887 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1890 else if (TREE_CODE (node
) == VOID_TYPE
)
1891 pp_string (pp
, "void");
1893 pp_string (pp
, "<unnamed type>");
1899 case REFERENCE_TYPE
:
1900 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1902 if (TREE_TYPE (node
) == NULL
)
1904 pp_string (pp
, str
);
1905 pp_string (pp
, "<null type>");
1907 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1909 tree fnode
= TREE_TYPE (node
);
1911 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1914 pp_string (pp
, str
);
1915 if (TYPE_IDENTIFIER (node
))
1916 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1917 else if (flags
& TDF_NOUID
)
1918 pp_string (pp
, "<Txxxx>");
1921 pp_string (pp
, "<T");
1922 pp_scalar (pp
, "%x", TYPE_UID (node
));
1923 pp_character (pp
, '>');
1926 pp_right_paren (pp
);
1927 dump_function_declaration (pp
, fnode
, spc
, flags
);
1931 unsigned int quals
= TYPE_QUALS (node
);
1933 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1935 pp_string (pp
, str
);
1937 if (quals
& TYPE_QUAL_CONST
)
1938 pp_string (pp
, " const");
1939 if (quals
& TYPE_QUAL_VOLATILE
)
1940 pp_string (pp
, " volatile");
1941 if (quals
& TYPE_QUAL_RESTRICT
)
1942 pp_string (pp
, " restrict");
1944 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1946 pp_string (pp
, " <address-space-");
1947 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1951 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1952 pp_string (pp
, " {ref-all}");
1961 case TARGET_MEM_REF
:
1962 dump_mem_ref (pp
, node
, spc
, flags
);
1967 unsigned int quals
= TYPE_QUALS (node
);
1970 if (quals
& TYPE_QUAL_ATOMIC
)
1971 pp_string (pp
, "atomic ");
1972 if (quals
& TYPE_QUAL_CONST
)
1973 pp_string (pp
, "const ");
1974 if (quals
& TYPE_QUAL_VOLATILE
)
1975 pp_string (pp
, "volatile ");
1977 /* Print the innermost component type. */
1978 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1979 tmp
= TREE_TYPE (tmp
))
1981 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1983 /* Print the dimensions. */
1984 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1985 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1991 case QUAL_UNION_TYPE
:
1993 unsigned int quals
= TYPE_QUALS (node
);
1995 if (quals
& TYPE_QUAL_ATOMIC
)
1996 pp_string (pp
, "atomic ");
1997 if (quals
& TYPE_QUAL_CONST
)
1998 pp_string (pp
, "const ");
1999 if (quals
& TYPE_QUAL_VOLATILE
)
2000 pp_string (pp
, "volatile ");
2002 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
2004 pp_string (pp
, "<address-space-");
2005 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
2006 pp_string (pp
, "> ");
2009 /* Print the name of the structure. */
2010 if (TREE_CODE (node
) == RECORD_TYPE
)
2011 pp_string (pp
, "struct ");
2012 else if (TREE_CODE (node
) == UNION_TYPE
)
2013 pp_string (pp
, "union ");
2015 if (TYPE_NAME (node
))
2016 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
2017 else if (!(flags
& TDF_SLIM
))
2018 /* FIXME: If we eliminate the 'else' above and attempt
2019 to show the fields for named types, we may get stuck
2020 following a cycle of pointers to structs. The alleged
2021 self-reference check in print_struct_decl will not detect
2022 cycles involving more than one pointer or struct type. */
2023 print_struct_decl (pp
, node
, spc
, flags
);
2032 if (flags
& TDF_GIMPLE
2033 && (POINTER_TYPE_P (TREE_TYPE (node
))
2034 || (TYPE_PRECISION (TREE_TYPE (node
))
2035 < TYPE_PRECISION (integer_type_node
))
2036 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1
2037 || tree_int_cst_sgn (node
) < 0))
2039 pp_string (pp
, "_Literal (");
2040 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2041 pp_string (pp
, ") ");
2043 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
2044 && ! (flags
& TDF_GIMPLE
))
2046 /* In the case of a pointer, one may want to divide by the
2047 size of the pointed-to type. Unfortunately, this not
2048 straightforward. The C front-end maps expressions
2053 in such a way that the two INTEGER_CST nodes for "5" have
2054 different values but identical types. In the latter
2055 case, the 5 is multiplied by sizeof (int) in c-common.c
2056 (pointer_int_sum) to convert it to a byte address, and
2057 yet the type of the node is left unchanged. Argh. What
2058 is consistent though is that the number value corresponds
2059 to bytes (UNITS) offset.
2061 NB: Neither of the following divisors can be trivially
2062 used to recover the original literal:
2064 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
2065 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
2066 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
2067 pp_string (pp
, "B"); /* pseudo-unit */
2069 else if (tree_fits_shwi_p (node
))
2070 pp_wide_integer (pp
, tree_to_shwi (node
));
2071 else if (tree_fits_uhwi_p (node
))
2072 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
2075 wide_int val
= wi::to_wide (node
);
2077 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
2082 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
2083 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
2085 if ((flags
& TDF_GIMPLE
)
2086 && ! (POINTER_TYPE_P (TREE_TYPE (node
))
2087 || (TYPE_PRECISION (TREE_TYPE (node
))
2088 < TYPE_PRECISION (integer_type_node
))
2089 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
2091 if (TYPE_UNSIGNED (TREE_TYPE (node
)))
2092 pp_character (pp
, 'u');
2093 if (TYPE_PRECISION (TREE_TYPE (node
))
2094 == TYPE_PRECISION (unsigned_type_node
))
2096 else if (TYPE_PRECISION (TREE_TYPE (node
))
2097 == TYPE_PRECISION (long_unsigned_type_node
))
2098 pp_character (pp
, 'l');
2099 else if (TYPE_PRECISION (TREE_TYPE (node
))
2100 == TYPE_PRECISION (long_long_unsigned_type_node
))
2101 pp_string (pp
, "ll");
2103 if (TREE_OVERFLOW (node
))
2104 pp_string (pp
, "(OVF)");
2108 pp_string (pp
, "POLY_INT_CST [");
2109 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, 0), spc
, flags
, false);
2110 for (unsigned int i
= 1; i
< NUM_POLY_INT_COEFFS
; ++i
)
2112 pp_string (pp
, ", ");
2113 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, i
),
2116 pp_string (pp
, "]");
2120 /* Code copied from print_node. */
2123 if (TREE_OVERFLOW (node
))
2124 pp_string (pp
, " overflow");
2126 d
= TREE_REAL_CST (node
);
2127 if (REAL_VALUE_ISINF (d
))
2128 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
2129 else if (REAL_VALUE_ISNAN (d
))
2130 pp_string (pp
, " Nan");
2134 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
2135 pp_string (pp
, string
);
2143 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
2144 pp_string (pp
, string
);
2149 pp_string (pp
, "__complex__ (");
2150 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
2151 pp_string (pp
, ", ");
2152 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
2153 pp_right_paren (pp
);
2158 pp_string (pp
, "\"");
2159 if (unsigned nbytes
= TREE_STRING_LENGTH (node
))
2160 pretty_print_string (pp
, TREE_STRING_POINTER (node
), nbytes
);
2161 pp_string (pp
, "\"");
2168 if (flags
& TDF_GIMPLE
)
2170 pp_string (pp
, "_Literal (");
2171 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2172 pp_string (pp
, ") ");
2174 pp_string (pp
, "{ ");
2175 unsigned HOST_WIDE_INT nunits
;
2176 if (!VECTOR_CST_NELTS (node
).is_constant (&nunits
))
2177 nunits
= vector_cst_encoded_nelts (node
);
2178 for (i
= 0; i
< nunits
; ++i
)
2181 pp_string (pp
, ", ");
2182 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
2185 if (!VECTOR_CST_NELTS (node
).is_constant ())
2186 pp_string (pp
, ", ...");
2187 pp_string (pp
, " }");
2193 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2195 if (TREE_CODE (node
) == METHOD_TYPE
)
2197 if (TYPE_METHOD_BASETYPE (node
))
2198 dump_generic_node (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
2201 pp_string (pp
, "<null method basetype>");
2202 pp_colon_colon (pp
);
2204 if (TYPE_IDENTIFIER (node
))
2205 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
2206 else if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
2207 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
2208 else if (flags
& TDF_NOUID
)
2209 pp_string (pp
, "<Txxxx>");
2212 pp_string (pp
, "<T");
2213 pp_scalar (pp
, "%x", TYPE_UID (node
));
2214 pp_character (pp
, '>');
2216 dump_function_declaration (pp
, node
, spc
, flags
);
2221 dump_decl_name (pp
, node
, flags
);
2225 if (DECL_NAME (node
))
2226 dump_decl_name (pp
, node
, flags
);
2227 else if (LABEL_DECL_UID (node
) != -1)
2229 if (flags
& TDF_GIMPLE
)
2231 pp_character (pp
, 'L');
2232 pp_decimal_int (pp
, (int) LABEL_DECL_UID (node
));
2236 pp_string (pp
, "<L");
2237 pp_decimal_int (pp
, (int) LABEL_DECL_UID (node
));
2238 pp_character (pp
, '>');
2243 if (flags
& TDF_NOUID
)
2244 pp_string (pp
, "<D.xxxx>");
2247 if (flags
& TDF_GIMPLE
)
2249 pp_character (pp
, 'D');
2250 pp_scalar (pp
, "%u", DECL_UID (node
));
2254 pp_string (pp
, "<D.");
2255 pp_scalar (pp
, "%u", DECL_UID (node
));
2256 pp_character (pp
, '>');
2263 if (DECL_IS_UNDECLARED_BUILTIN (node
))
2265 /* Don't print the declaration of built-in types. */
2268 if (DECL_NAME (node
))
2269 dump_decl_name (pp
, node
, flags
);
2270 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
2272 pp_string (pp
, (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
2273 ? "union" : "struct "));
2274 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2277 pp_string (pp
, "<anon>");
2283 case DEBUG_EXPR_DECL
:
2284 case NAMESPACE_DECL
:
2286 dump_decl_name (pp
, node
, flags
);
2290 pp_string (pp
, "<retval>");
2294 op0
= TREE_OPERAND (node
, 0);
2297 && (TREE_CODE (op0
) == INDIRECT_REF
2298 || (TREE_CODE (op0
) == MEM_REF
2299 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
2300 && integer_zerop (TREE_OPERAND (op0
, 1))
2301 /* Dump the types of INTEGER_CSTs explicitly, for we
2302 can't infer them and MEM_ATTR caching will share
2303 MEM_REFs with differently-typed op0s. */
2304 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
2305 /* Released SSA_NAMES have no TREE_TYPE. */
2306 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
2307 /* Same pointer types, but ignoring POINTER_TYPE vs.
2309 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2310 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2311 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2312 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2313 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2314 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2315 /* Same value types ignoring qualifiers. */
2316 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
2317 == TYPE_MAIN_VARIANT
2318 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
2319 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
2321 op0
= TREE_OPERAND (op0
, 0);
2324 if (op_prio (op0
) < op_prio (node
))
2326 dump_generic_node (pp
, op0
, spc
, flags
, false);
2327 if (op_prio (op0
) < op_prio (node
))
2328 pp_right_paren (pp
);
2329 pp_string (pp
, str
);
2330 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2331 op0
= component_ref_field_offset (node
);
2332 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
2334 pp_string (pp
, "{off: ");
2335 dump_generic_node (pp
, op0
, spc
, flags
, false);
2336 pp_right_brace (pp
);
2341 if (flags
& TDF_GIMPLE
)
2343 pp_string (pp
, "__BIT_FIELD_REF <");
2344 dump_generic_node (pp
, TREE_TYPE (node
),
2345 spc
, flags
| TDF_SLIM
, false);
2346 if (TYPE_ALIGN (TREE_TYPE (node
))
2347 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
2349 pp_string (pp
, ", ");
2350 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
2353 pp_string (pp
, " (");
2354 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
,
2355 flags
| TDF_SLIM
, false);
2356 pp_string (pp
, ", ");
2357 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
,
2358 flags
| TDF_SLIM
, false);
2359 pp_string (pp
, ", ");
2360 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
,
2361 flags
| TDF_SLIM
, false);
2362 pp_right_paren (pp
);
2366 pp_string (pp
, "BIT_FIELD_REF <");
2367 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2368 pp_string (pp
, ", ");
2369 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2370 pp_string (pp
, ", ");
2371 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2376 case BIT_INSERT_EXPR
:
2377 pp_string (pp
, "BIT_INSERT_EXPR <");
2378 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2379 pp_string (pp
, ", ");
2380 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2381 pp_string (pp
, ", ");
2382 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2383 pp_string (pp
, " (");
2384 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
2386 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
2388 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
2390 pp_string (pp
, " bits)>");
2394 case ARRAY_RANGE_REF
:
2395 op0
= TREE_OPERAND (node
, 0);
2396 if (op_prio (op0
) < op_prio (node
))
2398 dump_generic_node (pp
, op0
, spc
, flags
, false);
2399 if (op_prio (op0
) < op_prio (node
))
2400 pp_right_paren (pp
);
2401 pp_left_bracket (pp
);
2402 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2403 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
2404 pp_string (pp
, " ...");
2405 pp_right_bracket (pp
);
2407 op0
= array_ref_low_bound (node
);
2408 op1
= array_ref_element_size (node
);
2410 if (!integer_zerop (op0
)
2411 || TREE_OPERAND (node
, 2)
2412 || TREE_OPERAND (node
, 3))
2414 pp_string (pp
, "{lb: ");
2415 dump_generic_node (pp
, op0
, spc
, flags
, false);
2416 pp_string (pp
, " sz: ");
2417 dump_generic_node (pp
, op1
, spc
, flags
, false);
2418 pp_right_brace (pp
);
2424 unsigned HOST_WIDE_INT ix
;
2426 bool is_struct_init
= false;
2427 bool is_array_init
= false;
2429 if (flags
& TDF_GIMPLE
)
2431 pp_string (pp
, "_Literal (");
2432 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2433 pp_string (pp
, ") ");
2436 if (TREE_CLOBBER_P (node
))
2437 pp_string (pp
, "CLOBBER");
2438 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
2439 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
2440 is_struct_init
= true;
2441 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
2442 && TYPE_DOMAIN (TREE_TYPE (node
))
2443 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
2444 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
2447 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
2448 is_array_init
= true;
2449 curidx
= wi::to_widest (minv
);
2451 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
2458 dump_generic_node (pp
, field
, spc
, flags
, false);
2461 else if (is_array_init
2462 && (TREE_CODE (field
) != INTEGER_CST
2463 || curidx
!= wi::to_widest (field
)))
2465 pp_left_bracket (pp
);
2466 if (TREE_CODE (field
) == RANGE_EXPR
)
2468 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
2470 pp_string (pp
, " ... ");
2471 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
2473 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
2474 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
2477 dump_generic_node (pp
, field
, spc
, flags
, false);
2478 if (TREE_CODE (field
) == INTEGER_CST
)
2479 curidx
= wi::to_widest (field
);
2480 pp_string (pp
, "]=");
2485 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
2486 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
2487 val
= TREE_OPERAND (val
, 0);
2488 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
2489 dump_decl_name (pp
, val
, flags
);
2491 dump_generic_node (pp
, val
, spc
, flags
, false);
2492 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2498 pp_right_brace (pp
);
2505 if (flags
& TDF_SLIM
)
2507 pp_string (pp
, "<COMPOUND_EXPR>");
2511 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2512 spc
, flags
, !(flags
& TDF_SLIM
));
2513 if (flags
& TDF_SLIM
)
2514 newline_and_indent (pp
, spc
);
2521 for (tp
= &TREE_OPERAND (node
, 1);
2522 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2523 tp
= &TREE_OPERAND (*tp
, 1))
2525 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2526 spc
, flags
, !(flags
& TDF_SLIM
));
2527 if (flags
& TDF_SLIM
)
2528 newline_and_indent (pp
, spc
);
2536 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2540 case STATEMENT_LIST
:
2542 tree_stmt_iterator si
;
2545 if (flags
& TDF_SLIM
)
2547 pp_string (pp
, "<STATEMENT_LIST>");
2551 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2554 newline_and_indent (pp
, spc
);
2557 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2564 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2569 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2574 pp_string (pp
, "TARGET_EXPR <");
2575 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2578 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2583 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2588 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2590 pp_string (pp
, "if (");
2591 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2592 pp_right_paren (pp
);
2593 /* The lowered cond_exprs should always be printed in full. */
2594 if (COND_EXPR_THEN (node
)
2595 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2596 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2597 && COND_EXPR_ELSE (node
)
2598 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2599 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2602 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2604 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2606 pp_string (pp
, " else ");
2607 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2611 else if (!(flags
& TDF_SLIM
))
2613 /* Output COND_EXPR_THEN. */
2614 if (COND_EXPR_THEN (node
))
2616 newline_and_indent (pp
, spc
+2);
2618 newline_and_indent (pp
, spc
+4);
2619 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2621 newline_and_indent (pp
, spc
+2);
2622 pp_right_brace (pp
);
2625 /* Output COND_EXPR_ELSE. */
2626 if (COND_EXPR_ELSE (node
)
2627 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2629 newline_and_indent (pp
, spc
);
2630 pp_string (pp
, "else");
2631 newline_and_indent (pp
, spc
+2);
2633 newline_and_indent (pp
, spc
+4);
2634 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2636 newline_and_indent (pp
, spc
+2);
2637 pp_right_brace (pp
);
2644 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2648 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2652 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2658 if (!(flags
& TDF_SLIM
))
2660 if (BIND_EXPR_VARS (node
))
2664 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2666 print_declaration (pp
, op0
, spc
+2, flags
);
2671 newline_and_indent (pp
, spc
+2);
2672 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2673 newline_and_indent (pp
, spc
);
2674 pp_right_brace (pp
);
2680 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2681 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2685 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2688 /* Print parameters. */
2693 call_expr_arg_iterator iter
;
2694 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2696 dump_generic_node (pp
, arg
, spc
, flags
, false);
2697 if (more_call_expr_args_p (&iter
))
2704 if (CALL_EXPR_VA_ARG_PACK (node
))
2706 if (call_expr_nargs (node
) > 0)
2711 pp_string (pp
, "__builtin_va_arg_pack ()");
2713 pp_right_paren (pp
);
2715 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2718 pp_string (pp
, " [static-chain: ");
2719 dump_generic_node (pp
, op1
, spc
, flags
, false);
2720 pp_right_bracket (pp
);
2723 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2724 pp_string (pp
, " [return slot optimization]");
2725 if (CALL_EXPR_TAILCALL (node
))
2726 pp_string (pp
, " [tail call]");
2729 case WITH_CLEANUP_EXPR
:
2733 case CLEANUP_POINT_EXPR
:
2734 pp_string (pp
, "<<cleanup_point ");
2735 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2736 pp_string (pp
, ">>");
2739 case PLACEHOLDER_EXPR
:
2740 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2741 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2745 /* Binary arithmetic and logic expressions. */
2746 case WIDEN_PLUS_EXPR
:
2747 case WIDEN_MINUS_EXPR
:
2748 case WIDEN_SUM_EXPR
:
2749 case WIDEN_MULT_EXPR
:
2751 case MULT_HIGHPART_EXPR
:
2753 case POINTER_PLUS_EXPR
:
2754 case POINTER_DIFF_EXPR
:
2756 case TRUNC_DIV_EXPR
:
2758 case FLOOR_DIV_EXPR
:
2759 case ROUND_DIV_EXPR
:
2760 case TRUNC_MOD_EXPR
:
2762 case FLOOR_MOD_EXPR
:
2763 case ROUND_MOD_EXPR
:
2765 case EXACT_DIV_EXPR
:
2770 case WIDEN_LSHIFT_EXPR
:
2774 case TRUTH_ANDIF_EXPR
:
2775 case TRUTH_ORIF_EXPR
:
2776 case TRUTH_AND_EXPR
:
2778 case TRUTH_XOR_EXPR
:
2792 case UNORDERED_EXPR
:
2794 const char *op
= op_symbol (node
);
2795 op0
= TREE_OPERAND (node
, 0);
2796 op1
= TREE_OPERAND (node
, 1);
2798 /* When the operands are expressions with less priority,
2799 keep semantics of the tree representation. */
2800 if (op_prio (op0
) <= op_prio (node
))
2803 dump_generic_node (pp
, op0
, spc
, flags
, false);
2804 pp_right_paren (pp
);
2807 dump_generic_node (pp
, op0
, spc
, flags
, false);
2813 /* When the operands are expressions with less priority,
2814 keep semantics of the tree representation. */
2815 if (op_prio (op1
) <= op_prio (node
))
2818 dump_generic_node (pp
, op1
, spc
, flags
, false);
2819 pp_right_paren (pp
);
2822 dump_generic_node (pp
, op1
, spc
, flags
, false);
2826 /* Unary arithmetic and logic expressions. */
2829 case TRUTH_NOT_EXPR
:
2831 case PREDECREMENT_EXPR
:
2832 case PREINCREMENT_EXPR
:
2834 if (TREE_CODE (node
) == ADDR_EXPR
2835 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2836 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2837 ; /* Do not output '&' for strings and function pointers. */
2839 pp_string (pp
, op_symbol (node
));
2841 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2844 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2845 pp_right_paren (pp
);
2848 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2851 case POSTDECREMENT_EXPR
:
2852 case POSTINCREMENT_EXPR
:
2853 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2856 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2857 pp_right_paren (pp
);
2860 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2861 pp_string (pp
, op_symbol (node
));
2865 pp_string (pp
, "MIN_EXPR <");
2866 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2867 pp_string (pp
, ", ");
2868 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2873 pp_string (pp
, "MAX_EXPR <");
2874 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2875 pp_string (pp
, ", ");
2876 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2881 pp_string (pp
, "ABS_EXPR <");
2882 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2887 pp_string (pp
, "ABSU_EXPR <");
2888 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2896 case ADDR_SPACE_CONVERT_EXPR
:
2897 case FIXED_CONVERT_EXPR
:
2898 case FIX_TRUNC_EXPR
:
2901 type
= TREE_TYPE (node
);
2902 op0
= TREE_OPERAND (node
, 0);
2903 if (type
!= TREE_TYPE (op0
))
2906 dump_generic_node (pp
, type
, spc
, flags
, false);
2907 pp_string (pp
, ") ");
2909 if (op_prio (op0
) < op_prio (node
))
2911 dump_generic_node (pp
, op0
, spc
, flags
, false);
2912 if (op_prio (op0
) < op_prio (node
))
2913 pp_right_paren (pp
);
2916 case VIEW_CONVERT_EXPR
:
2917 if (flags
& TDF_GIMPLE
)
2918 pp_string (pp
, "__VIEW_CONVERT <");
2920 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2921 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2922 pp_string (pp
, ">(");
2923 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2924 pp_right_paren (pp
);
2928 pp_string (pp
, "((");
2929 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2930 pp_string (pp
, "))");
2933 case NON_LVALUE_EXPR
:
2934 pp_string (pp
, "NON_LVALUE_EXPR <");
2935 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2940 pp_string (pp
, "SAVE_EXPR <");
2941 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2946 pp_string (pp
, "COMPLEX_EXPR <");
2947 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2948 pp_string (pp
, ", ");
2949 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2954 pp_string (pp
, "CONJ_EXPR <");
2955 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2960 if (flags
& TDF_GIMPLE
)
2962 pp_string (pp
, "__real ");
2963 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2967 pp_string (pp
, "REALPART_EXPR <");
2968 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2974 if (flags
& TDF_GIMPLE
)
2976 pp_string (pp
, "__imag ");
2977 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2981 pp_string (pp
, "IMAGPART_EXPR <");
2982 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2988 pp_string (pp
, "VA_ARG_EXPR <");
2989 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2993 case TRY_FINALLY_EXPR
:
2994 case TRY_CATCH_EXPR
:
2995 pp_string (pp
, "try");
2996 newline_and_indent (pp
, spc
+2);
2998 newline_and_indent (pp
, spc
+4);
2999 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
3000 newline_and_indent (pp
, spc
+2);
3001 pp_right_brace (pp
);
3002 newline_and_indent (pp
, spc
);
3003 if (TREE_CODE (node
) == TRY_CATCH_EXPR
)
3005 node
= TREE_OPERAND (node
, 1);
3006 pp_string (pp
, "catch");
3010 gcc_assert (TREE_CODE (node
) == TRY_FINALLY_EXPR
);
3011 node
= TREE_OPERAND (node
, 1);
3012 pp_string (pp
, "finally");
3013 if (TREE_CODE (node
) == EH_ELSE_EXPR
)
3015 newline_and_indent (pp
, spc
+2);
3017 newline_and_indent (pp
, spc
+4);
3018 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4,
3020 newline_and_indent (pp
, spc
+2);
3021 pp_right_brace (pp
);
3022 newline_and_indent (pp
, spc
);
3023 node
= TREE_OPERAND (node
, 1);
3024 pp_string (pp
, "else");
3027 newline_and_indent (pp
, spc
+2);
3029 newline_and_indent (pp
, spc
+4);
3030 dump_generic_node (pp
, node
, spc
+4, flags
, true);
3031 newline_and_indent (pp
, spc
+2);
3032 pp_right_brace (pp
);
3037 pp_string (pp
, "catch (");
3038 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
3039 pp_right_paren (pp
);
3040 newline_and_indent (pp
, spc
+2);
3042 newline_and_indent (pp
, spc
+4);
3043 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
3044 newline_and_indent (pp
, spc
+2);
3045 pp_right_brace (pp
);
3049 case EH_FILTER_EXPR
:
3050 pp_string (pp
, "<<<eh_filter (");
3051 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
3052 pp_string (pp
, ")>>>");
3053 newline_and_indent (pp
, spc
+2);
3055 newline_and_indent (pp
, spc
+4);
3056 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
3057 newline_and_indent (pp
, spc
+2);
3058 pp_right_brace (pp
);
3063 op0
= TREE_OPERAND (node
, 0);
3064 /* If this is for break or continue, don't bother printing it. */
3065 if (DECL_NAME (op0
))
3067 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
3068 if (strcmp (name
, "break") == 0
3069 || strcmp (name
, "continue") == 0)
3072 dump_generic_node (pp
, op0
, spc
, flags
, false);
3074 if (DECL_NONLOCAL (op0
))
3075 pp_string (pp
, " [non-local]");
3079 pp_string (pp
, "while (1)");
3080 if (!(flags
& TDF_SLIM
))
3082 newline_and_indent (pp
, spc
+2);
3084 newline_and_indent (pp
, spc
+4);
3085 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
3086 newline_and_indent (pp
, spc
+2);
3087 pp_right_brace (pp
);
3093 pp_string (pp
, "// predicted ");
3094 if (PREDICT_EXPR_OUTCOME (node
))
3095 pp_string (pp
, "likely by ");
3097 pp_string (pp
, "unlikely by ");
3098 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
3099 pp_string (pp
, " predictor.");
3103 pp_string (pp
, "ANNOTATE_EXPR <");
3104 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3105 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
3107 case annot_expr_ivdep_kind
:
3108 pp_string (pp
, ", ivdep");
3110 case annot_expr_unroll_kind
:
3112 pp_string (pp
, ", unroll ");
3114 (int) TREE_INT_CST_LOW (TREE_OPERAND (node
, 2)));
3117 case annot_expr_no_vector_kind
:
3118 pp_string (pp
, ", no-vector");
3120 case annot_expr_vector_kind
:
3121 pp_string (pp
, ", vector");
3123 case annot_expr_parallel_kind
:
3124 pp_string (pp
, ", parallel");
3133 pp_string (pp
, "return");
3134 op0
= TREE_OPERAND (node
, 0);
3138 if (TREE_CODE (op0
) == MODIFY_EXPR
)
3139 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
3142 dump_generic_node (pp
, op0
, spc
, flags
, false);
3147 pp_string (pp
, "if (");
3148 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3149 pp_string (pp
, ") break");
3153 pp_string (pp
, "switch (");
3154 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
3155 pp_right_paren (pp
);
3156 if (!(flags
& TDF_SLIM
))
3158 newline_and_indent (pp
, spc
+2);
3160 if (SWITCH_BODY (node
))
3162 newline_and_indent (pp
, spc
+4);
3163 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
3166 newline_and_indent (pp
, spc
+2);
3167 pp_right_brace (pp
);
3173 op0
= GOTO_DESTINATION (node
);
3174 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
3176 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
3177 if (strcmp (name
, "break") == 0
3178 || strcmp (name
, "continue") == 0)
3180 pp_string (pp
, name
);
3184 pp_string (pp
, "goto ");
3185 dump_generic_node (pp
, op0
, spc
, flags
, false);
3189 pp_string (pp
, "__asm__");
3190 if (ASM_VOLATILE_P (node
))
3191 pp_string (pp
, " __volatile__");
3193 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
3195 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
3197 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
3198 if (ASM_CLOBBERS (node
))
3201 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
3203 pp_right_paren (pp
);
3206 case CASE_LABEL_EXPR
:
3207 if (CASE_LOW (node
) && CASE_HIGH (node
))
3209 pp_string (pp
, "case ");
3210 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
3211 pp_string (pp
, " ... ");
3212 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
3214 else if (CASE_LOW (node
))
3216 pp_string (pp
, "case ");
3217 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
3220 pp_string (pp
, "default");
3225 pp_string (pp
, "OBJ_TYPE_REF(");
3226 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
3228 /* We omit the class type for -fcompare-debug because we may
3229 drop TYPE_BINFO early depending on debug info, and then
3230 virtual_method_call_p would return false, whereas when
3231 TYPE_BINFO is preserved it may still return true and then
3232 we'd print the class type. Compare tree and rtl dumps for
3233 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
3234 for example, at occurrences of OBJ_TYPE_REF. */
3235 if (!(flags
& (TDF_SLIM
| TDF_COMPARE_DEBUG
))
3236 && virtual_method_call_p (node
, true))
3238 pp_string (pp
, "(");
3239 dump_generic_node (pp
, obj_type_ref_class (node
, true),
3241 pp_string (pp
, ")");
3243 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
3245 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
3246 pp_right_paren (pp
);
3250 if (SSA_NAME_IDENTIFIER (node
))
3252 if ((flags
& TDF_NOUID
)
3253 && SSA_NAME_VAR (node
)
3254 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
3255 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
3256 else if (! (flags
& TDF_GIMPLE
)
3257 || SSA_NAME_VAR (node
))
3258 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
3262 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
3263 if (SSA_NAME_IS_DEFAULT_DEF (node
))
3264 pp_string (pp
, "(D)");
3265 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
3266 pp_string (pp
, "(ab)");
3269 case WITH_SIZE_EXPR
:
3270 pp_string (pp
, "WITH_SIZE_EXPR <");
3271 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3272 pp_string (pp
, ", ");
3273 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3278 pp_string (pp
, "ASSERT_EXPR <");
3279 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
3280 pp_string (pp
, ", ");
3281 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
3286 pp_string (pp
, "scev_known");
3289 case SCEV_NOT_KNOWN
:
3290 pp_string (pp
, "scev_not_known");
3293 case POLYNOMIAL_CHREC
:
3295 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
3296 pp_string (pp
, ", +, ");
3297 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
3298 pp_string (pp
, "}_");
3299 pp_scalar (pp
, "%u", CHREC_VARIABLE (node
));
3303 case REALIGN_LOAD_EXPR
:
3304 pp_string (pp
, "REALIGN_LOAD <");
3305 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3306 pp_string (pp
, ", ");
3307 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3308 pp_string (pp
, ", ");
3309 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3314 pp_string (pp
, " VEC_COND_EXPR < ");
3315 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3316 pp_string (pp
, " , ");
3317 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3318 pp_string (pp
, " , ");
3319 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3320 pp_string (pp
, " > ");
3324 pp_string (pp
, " VEC_PERM_EXPR < ");
3325 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3326 pp_string (pp
, " , ");
3327 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3328 pp_string (pp
, " , ");
3329 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3330 pp_string (pp
, " > ");
3334 pp_string (pp
, " DOT_PROD_EXPR < ");
3335 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3336 pp_string (pp
, ", ");
3337 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3338 pp_string (pp
, ", ");
3339 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3340 pp_string (pp
, " > ");
3343 case WIDEN_MULT_PLUS_EXPR
:
3344 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
3345 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3346 pp_string (pp
, ", ");
3347 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3348 pp_string (pp
, ", ");
3349 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3350 pp_string (pp
, " > ");
3353 case WIDEN_MULT_MINUS_EXPR
:
3354 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
3355 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3356 pp_string (pp
, ", ");
3357 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3358 pp_string (pp
, ", ");
3359 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3360 pp_string (pp
, " > ");
3364 pp_string (pp
, "#pragma acc parallel");
3365 goto dump_omp_clauses_body
;
3368 pp_string (pp
, "#pragma acc kernels");
3369 goto dump_omp_clauses_body
;
3372 pp_string (pp
, "#pragma acc serial");
3373 goto dump_omp_clauses_body
;
3376 pp_string (pp
, "#pragma acc data");
3377 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
3380 case OACC_HOST_DATA
:
3381 pp_string (pp
, "#pragma acc host_data");
3382 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
3386 pp_string (pp
, "#pragma acc declare");
3387 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
3391 pp_string (pp
, "#pragma acc update");
3392 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
3395 case OACC_ENTER_DATA
:
3396 pp_string (pp
, "#pragma acc enter data");
3397 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3400 case OACC_EXIT_DATA
:
3401 pp_string (pp
, "#pragma acc exit data");
3402 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3406 pp_string (pp
, "#pragma acc cache");
3407 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
3411 pp_string (pp
, "#pragma omp parallel");
3412 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
3415 dump_omp_clauses_body
:
3416 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
3420 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
3422 newline_and_indent (pp
, spc
+ 2);
3424 newline_and_indent (pp
, spc
+ 4);
3425 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
3426 newline_and_indent (pp
, spc
+ 2);
3427 pp_right_brace (pp
);
3433 pp_string (pp
, OMP_TASK_BODY (node
) ? "#pragma omp task"
3434 : "#pragma omp taskwait");
3435 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
3439 pp_string (pp
, "#pragma omp for");
3443 pp_string (pp
, "#pragma omp simd");
3446 case OMP_DISTRIBUTE
:
3447 pp_string (pp
, "#pragma omp distribute");
3451 pp_string (pp
, "#pragma omp taskloop");
3455 pp_string (pp
, "#pragma omp loop");
3459 pp_string (pp
, "#pragma acc loop");
3463 pp_string (pp
, "#pragma omp teams");
3464 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
3467 case OMP_TARGET_DATA
:
3468 pp_string (pp
, "#pragma omp target data");
3469 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
3472 case OMP_TARGET_ENTER_DATA
:
3473 pp_string (pp
, "#pragma omp target enter data");
3474 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3478 case OMP_TARGET_EXIT_DATA
:
3479 pp_string (pp
, "#pragma omp target exit data");
3480 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3485 pp_string (pp
, "#pragma omp target");
3486 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3489 case OMP_TARGET_UPDATE
:
3490 pp_string (pp
, "#pragma omp target update");
3491 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3496 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3497 if (!(flags
& TDF_SLIM
))
3501 if (OMP_FOR_PRE_BODY (node
))
3503 newline_and_indent (pp
, spc
+ 2);
3506 newline_and_indent (pp
, spc
);
3507 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3510 if (OMP_FOR_INIT (node
))
3513 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3516 newline_and_indent (pp
, spc
);
3517 pp_string (pp
, "for (");
3518 tree init
= TREE_VEC_ELT (OMP_FOR_INIT (node
), i
);
3519 if (TREE_CODE (init
) != MODIFY_EXPR
3520 || TREE_CODE (TREE_OPERAND (init
, 1)) != TREE_VEC
)
3521 dump_generic_node (pp
, init
, spc
, flags
, false);
3524 dump_generic_node (pp
, TREE_OPERAND (init
, 0),
3526 pp_string (pp
, " = ");
3527 dump_omp_loop_non_rect_expr (pp
, TREE_OPERAND (init
, 1),
3530 pp_string (pp
, "; ");
3531 tree cond
= TREE_VEC_ELT (OMP_FOR_COND (node
), i
);
3532 if (!COMPARISON_CLASS_P (cond
)
3533 || TREE_CODE (TREE_OPERAND (cond
, 1)) != TREE_VEC
)
3534 dump_generic_node (pp
, cond
, spc
, flags
, false);
3537 dump_generic_node (pp
, TREE_OPERAND (cond
, 0),
3539 const char *op
= op_symbol (cond
);
3543 dump_omp_loop_non_rect_expr (pp
, TREE_OPERAND (cond
, 1),
3546 pp_string (pp
, "; ");
3547 dump_generic_node (pp
,
3548 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3550 pp_right_paren (pp
);
3553 if (OMP_FOR_BODY (node
))
3555 newline_and_indent (pp
, spc
+ 2);
3557 newline_and_indent (pp
, spc
+ 4);
3558 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3560 newline_and_indent (pp
, spc
+ 2);
3561 pp_right_brace (pp
);
3563 if (OMP_FOR_INIT (node
))
3564 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3565 if (OMP_FOR_PRE_BODY (node
))
3568 newline_and_indent (pp
, spc
+ 2);
3569 pp_right_brace (pp
);
3576 pp_string (pp
, "#pragma omp sections");
3577 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3581 pp_string (pp
, "#pragma omp section");
3585 if (OMP_SCAN_CLAUSES (node
))
3587 pp_string (pp
, "#pragma omp scan");
3588 dump_omp_clauses (pp
, OMP_SCAN_CLAUSES (node
), spc
, flags
);
3593 pp_string (pp
, "#pragma omp master");
3597 pp_string (pp
, "#pragma omp masked");
3598 dump_omp_clauses (pp
, OMP_MASKED_CLAUSES (node
), spc
, flags
);
3602 pp_string (pp
, "#pragma omp taskgroup");
3603 dump_omp_clauses (pp
, OMP_TASKGROUP_CLAUSES (node
), spc
, flags
);
3607 pp_string (pp
, "#pragma omp ordered");
3608 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3612 pp_string (pp
, "#pragma omp critical");
3613 if (OMP_CRITICAL_NAME (node
))
3617 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3619 pp_right_paren (pp
);
3621 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3625 pp_string (pp
, "#pragma omp atomic");
3626 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3627 newline_and_indent (pp
, spc
+ 2);
3628 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3632 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3635 case OMP_ATOMIC_READ
:
3636 pp_string (pp
, "#pragma omp atomic read");
3637 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3638 newline_and_indent (pp
, spc
+ 2);
3639 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3643 case OMP_ATOMIC_CAPTURE_OLD
:
3644 case OMP_ATOMIC_CAPTURE_NEW
:
3645 pp_string (pp
, "#pragma omp atomic capture");
3646 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3647 newline_and_indent (pp
, spc
+ 2);
3648 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3652 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3656 pp_string (pp
, "#pragma omp single");
3657 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3661 pp_string (pp
, "#pragma omp scope");
3662 dump_omp_clauses (pp
, OMP_SCOPE_CLAUSES (node
), spc
, flags
);
3666 /* If we come here, we're dumping something that's not an OMP construct,
3667 for example, OMP clauses attached to a function's '__attribute__'.
3668 Dump the whole OMP clause chain. */
3669 dump_omp_clauses (pp
, node
, spc
, flags
, false);
3673 case TRANSACTION_EXPR
:
3674 if (TRANSACTION_EXPR_OUTER (node
))
3675 pp_string (pp
, "__transaction_atomic [[outer]]");
3676 else if (TRANSACTION_EXPR_RELAXED (node
))
3677 pp_string (pp
, "__transaction_relaxed");
3679 pp_string (pp
, "__transaction_atomic");
3680 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3682 newline_and_indent (pp
, spc
);
3684 newline_and_indent (pp
, spc
+ 2);
3685 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3686 spc
+ 2, flags
, false);
3687 newline_and_indent (pp
, spc
);
3688 pp_right_brace (pp
);
3693 case VEC_SERIES_EXPR
:
3694 case VEC_WIDEN_MULT_HI_EXPR
:
3695 case VEC_WIDEN_MULT_LO_EXPR
:
3696 case VEC_WIDEN_PLUS_HI_EXPR
:
3697 case VEC_WIDEN_PLUS_LO_EXPR
:
3698 case VEC_WIDEN_MINUS_HI_EXPR
:
3699 case VEC_WIDEN_MINUS_LO_EXPR
:
3700 case VEC_WIDEN_MULT_EVEN_EXPR
:
3701 case VEC_WIDEN_MULT_ODD_EXPR
:
3702 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3703 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3705 for (str
= get_tree_code_name (code
); *str
; str
++)
3706 pp_character (pp
, TOUPPER (*str
));
3707 pp_string (pp
, " < ");
3708 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3709 pp_string (pp
, ", ");
3710 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3711 pp_string (pp
, " > ");
3714 case VEC_DUPLICATE_EXPR
:
3716 for (str
= get_tree_code_name (code
); *str
; str
++)
3717 pp_character (pp
, TOUPPER (*str
));
3718 pp_string (pp
, " < ");
3719 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3720 pp_string (pp
, " > ");
3723 case VEC_UNPACK_HI_EXPR
:
3724 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3725 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3726 pp_string (pp
, " > ");
3729 case VEC_UNPACK_LO_EXPR
:
3730 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3731 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3732 pp_string (pp
, " > ");
3735 case VEC_UNPACK_FLOAT_HI_EXPR
:
3736 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3737 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3738 pp_string (pp
, " > ");
3741 case VEC_UNPACK_FLOAT_LO_EXPR
:
3742 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3743 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3744 pp_string (pp
, " > ");
3747 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3748 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
3749 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3750 pp_string (pp
, " > ");
3753 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3754 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
3755 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3756 pp_string (pp
, " > ");
3759 case VEC_PACK_TRUNC_EXPR
:
3760 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3761 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3762 pp_string (pp
, ", ");
3763 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3764 pp_string (pp
, " > ");
3767 case VEC_PACK_SAT_EXPR
:
3768 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3769 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3770 pp_string (pp
, ", ");
3771 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3772 pp_string (pp
, " > ");
3775 case VEC_PACK_FIX_TRUNC_EXPR
:
3776 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3777 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3778 pp_string (pp
, ", ");
3779 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3780 pp_string (pp
, " > ");
3783 case VEC_PACK_FLOAT_EXPR
:
3784 pp_string (pp
, " VEC_PACK_FLOAT_EXPR < ");
3785 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3786 pp_string (pp
, ", ");
3787 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3788 pp_string (pp
, " > ");
3792 dump_block_node (pp
, node
, spc
, flags
);
3795 case DEBUG_BEGIN_STMT
:
3796 pp_string (pp
, "# DEBUG BEGIN STMT");
3803 if (is_stmt
&& is_expr
)
3809 /* Print the declaration of a variable. */
3812 print_declaration (pretty_printer
*pp
, tree t
, int spc
, dump_flags_t flags
)
3816 if (TREE_CODE(t
) == NAMELIST_DECL
)
3818 pp_string(pp
, "namelist ");
3819 dump_decl_name (pp
, t
, flags
);
3824 if (TREE_CODE (t
) == TYPE_DECL
)
3825 pp_string (pp
, "typedef ");
3827 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3828 pp_string (pp
, "register ");
3830 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3831 pp_string (pp
, "extern ");
3832 else if (TREE_STATIC (t
))
3833 pp_string (pp
, "static ");
3835 /* Print the type and name. */
3836 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3840 /* Print array's type. */
3841 tmp
= TREE_TYPE (t
);
3842 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3843 tmp
= TREE_TYPE (tmp
);
3844 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3846 /* Print variable's name. */
3848 dump_generic_node (pp
, t
, spc
, flags
, false);
3850 /* Print the dimensions. */
3851 tmp
= TREE_TYPE (t
);
3852 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3854 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3855 tmp
= TREE_TYPE (tmp
);
3858 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3860 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3862 dump_decl_name (pp
, t
, flags
);
3863 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3867 /* Print type declaration. */
3868 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3870 /* Print variable's name. */
3872 dump_generic_node (pp
, t
, spc
, flags
, false);
3875 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
3877 pp_string (pp
, " __asm__ ");
3879 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3880 pp_right_paren (pp
);
3883 /* The initial value of a function serves to determine whether the function
3884 is declared or defined. So the following does not apply to function
3886 if (TREE_CODE (t
) != FUNCTION_DECL
)
3888 /* Print the initial value. */
3889 if (DECL_INITIAL (t
))
3894 if (!(flags
& TDF_SLIM
))
3895 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3897 pp_string (pp
, "<<< omitted >>>");
3901 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3903 pp_string (pp
, " [value-expr: ");
3904 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3905 pp_right_bracket (pp
);
3912 /* Prints a structure: name, fields, and methods.
3913 FIXME: Still incomplete. */
3916 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
3919 /* Print the name of the structure. */
3920 if (TYPE_NAME (node
))
3923 if (TREE_CODE (node
) == RECORD_TYPE
)
3924 pp_string (pp
, "struct ");
3925 else if ((TREE_CODE (node
) == UNION_TYPE
3926 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3927 pp_string (pp
, "union ");
3929 dump_generic_node (pp
, TYPE_NAME (node
), spc
, TDF_NONE
, false);
3932 /* Print the contents of the structure. */
3938 /* Print the fields of the structure. */
3941 tmp
= TYPE_FIELDS (node
);
3944 /* Avoid to print recursively the structure. */
3945 /* FIXME : Not implemented correctly...,
3946 what about the case when we have a cycle in the contain graph? ...
3947 Maybe this could be solved by looking at the scope in which the
3948 structure was declared. */
3949 if (TREE_TYPE (tmp
) != node
3950 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3951 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3953 print_declaration (pp
, tmp
, spc
+2, flags
);
3956 tmp
= DECL_CHAIN (tmp
);
3960 pp_right_brace (pp
);
3963 /* Return the priority of the operator CODE.
3965 From lowest to highest precedence with either left-to-right (L-R)
3966 or right-to-left (R-L) associativity]:
3969 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3981 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3982 15 [L-R] fn() [] -> .
3984 unary +, - and * have higher precedence than the corresponding binary
3988 op_code_prio (enum tree_code code
)
4005 case TRUTH_ORIF_EXPR
:
4008 case TRUTH_AND_EXPR
:
4009 case TRUTH_ANDIF_EXPR
:
4016 case TRUTH_XOR_EXPR
:
4033 case UNORDERED_EXPR
:
4044 case VEC_WIDEN_LSHIFT_HI_EXPR
:
4045 case VEC_WIDEN_LSHIFT_LO_EXPR
:
4046 case WIDEN_LSHIFT_EXPR
:
4049 case WIDEN_SUM_EXPR
:
4051 case POINTER_PLUS_EXPR
:
4052 case POINTER_DIFF_EXPR
:
4056 case VEC_WIDEN_MULT_HI_EXPR
:
4057 case VEC_WIDEN_MULT_LO_EXPR
:
4058 case WIDEN_MULT_EXPR
:
4060 case WIDEN_MULT_PLUS_EXPR
:
4061 case WIDEN_MULT_MINUS_EXPR
:
4063 case MULT_HIGHPART_EXPR
:
4064 case TRUNC_DIV_EXPR
:
4066 case FLOOR_DIV_EXPR
:
4067 case ROUND_DIV_EXPR
:
4069 case EXACT_DIV_EXPR
:
4070 case TRUNC_MOD_EXPR
:
4072 case FLOOR_MOD_EXPR
:
4073 case ROUND_MOD_EXPR
:
4076 case TRUTH_NOT_EXPR
:
4078 case POSTINCREMENT_EXPR
:
4079 case POSTDECREMENT_EXPR
:
4080 case PREINCREMENT_EXPR
:
4081 case PREDECREMENT_EXPR
:
4087 case FIX_TRUNC_EXPR
:
4093 case ARRAY_RANGE_REF
:
4097 /* Special expressions. */
4103 case VEC_UNPACK_HI_EXPR
:
4104 case VEC_UNPACK_LO_EXPR
:
4105 case VEC_UNPACK_FLOAT_HI_EXPR
:
4106 case VEC_UNPACK_FLOAT_LO_EXPR
:
4107 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
4108 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
4109 case VEC_PACK_TRUNC_EXPR
:
4110 case VEC_PACK_SAT_EXPR
:
4114 /* Return an arbitrarily high precedence to avoid surrounding single
4115 VAR_DECLs in ()s. */
4120 /* Return the priority of the operator OP. */
4123 op_prio (const_tree op
)
4125 enum tree_code code
;
4130 code
= TREE_CODE (op
);
4131 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
4132 return op_prio (TREE_OPERAND (op
, 0));
4134 return op_code_prio (code
);
4137 /* Return the symbol associated with operator CODE. */
4140 op_symbol_code (enum tree_code code
)
4148 case TRUTH_ORIF_EXPR
:
4151 case TRUTH_AND_EXPR
:
4152 case TRUTH_ANDIF_EXPR
:
4158 case TRUTH_XOR_EXPR
:
4168 case UNORDERED_EXPR
:
4214 case WIDEN_LSHIFT_EXPR
:
4217 case WIDEN_PLUS_EXPR
:
4220 case WIDEN_MINUS_EXPR
:
4223 case POINTER_PLUS_EXPR
:
4229 case WIDEN_SUM_EXPR
:
4232 case WIDEN_MULT_EXPR
:
4235 case MULT_HIGHPART_EXPR
:
4240 case POINTER_DIFF_EXPR
:
4246 case TRUTH_NOT_EXPR
:
4253 case TRUNC_DIV_EXPR
:
4260 case FLOOR_DIV_EXPR
:
4263 case ROUND_DIV_EXPR
:
4266 case EXACT_DIV_EXPR
:
4269 case TRUNC_MOD_EXPR
:
4275 case FLOOR_MOD_EXPR
:
4278 case ROUND_MOD_EXPR
:
4281 case PREDECREMENT_EXPR
:
4284 case PREINCREMENT_EXPR
:
4287 case POSTDECREMENT_EXPR
:
4290 case POSTINCREMENT_EXPR
:
4300 return "<<< ??? >>>";
4304 /* Return the symbol associated with operator OP. */
4307 op_symbol (const_tree op
)
4309 return op_symbol_code (TREE_CODE (op
));
4312 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
4313 the gimple_call_fn of a GIMPLE_CALL. */
4316 print_call_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
4320 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
4321 op0
= TREE_OPERAND (op0
, 0);
4324 switch (TREE_CODE (op0
))
4329 dump_function_name (pp
, op0
, flags
);
4335 op0
= TREE_OPERAND (op0
, 0);
4340 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
4341 pp_string (pp
, ") ? ");
4342 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
4343 pp_string (pp
, " : ");
4344 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
4348 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
4349 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
4351 dump_generic_node (pp
, op0
, 0, flags
, false);
4355 if (integer_zerop (TREE_OPERAND (op0
, 1)))
4357 op0
= TREE_OPERAND (op0
, 0);
4364 dump_generic_node (pp
, op0
, 0, flags
, false);
4372 /* Print the first N characters in the array STR, replacing non-printable
4373 characters (including embedded nuls) with unambiguous escape sequences. */
4376 pretty_print_string (pretty_printer
*pp
, const char *str
, size_t n
)
4381 for ( ; n
; --n
, ++str
)
4386 pp_string (pp
, "\\b");
4390 pp_string (pp
, "\\f");
4394 pp_string (pp
, "\\n");
4398 pp_string (pp
, "\\r");
4402 pp_string (pp
, "\\t");
4406 pp_string (pp
, "\\v");
4410 pp_string (pp
, "\\\\");
4414 pp_string (pp
, "\\\"");
4418 pp_string (pp
, "\\'");
4422 if (str
[0] || n
> 1)
4424 if (!ISPRINT (str
[0]))
4427 sprintf (buf
, "\\x%02x", (unsigned char)str
[0]);
4428 pp_string (pp
, buf
);
4431 pp_character (pp
, str
[0]);
4439 maybe_init_pretty_print (FILE *file
)
4443 tree_pp
= new pretty_printer ();
4444 pp_needs_newline (tree_pp
) = true;
4445 pp_translate_identifiers (tree_pp
) = false;
4448 tree_pp
->buffer
->stream
= file
;
4452 newline_and_indent (pretty_printer
*pp
, int spc
)
4458 /* Print the identifier ID to PRETTY-PRINTER. */
4461 pp_tree_identifier (pretty_printer
*pp
, tree id
)
4463 if (pp_translate_identifiers (pp
))
4465 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
4466 pp_append_text (pp
, text
, text
+ strlen (text
));
4469 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
4470 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
4473 /* A helper function that is used to dump function information before the
4477 dump_function_header (FILE *dump_file
, tree fdecl
, dump_flags_t flags
)
4479 const char *dname
, *aname
;
4480 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
4481 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
4483 dname
= lang_hooks
.decl_printable_name (fdecl
, 1);
4485 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
4486 aname
= (IDENTIFIER_POINTER
4487 (DECL_ASSEMBLER_NAME (fdecl
)));
4489 aname
= "<unset-asm-name>";
4491 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
4492 dname
, aname
, fun
->funcdef_no
);
4493 if (!(flags
& TDF_NOUID
))
4494 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
4497 fprintf (dump_file
, ", cgraph_uid=%d", node
->get_uid ());
4498 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
4499 node
->frequency
== NODE_FREQUENCY_HOT
4501 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
4502 ? " (unlikely executed)"
4503 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
4504 ? " (executed once)"
4508 fprintf (dump_file
, ")\n\n");
4511 /* Dump double_int D to pretty_printer PP. UNS is true
4512 if D is unsigned and false otherwise. */
4514 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4517 pp_wide_integer (pp
, d
.low
);
4518 else if (d
.fits_uhwi ())
4519 pp_unsigned_wide_integer (pp
, d
.low
);
4522 unsigned HOST_WIDE_INT low
= d
.low
;
4523 HOST_WIDE_INT high
= d
.high
;
4524 if (!uns
&& d
.is_negative ())
4527 high
= ~high
+ !low
;
4530 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4532 sprintf (pp_buffer (pp
)->digit_buffer
,
4533 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4534 (unsigned HOST_WIDE_INT
) high
, low
);
4535 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
4540 # pragma GCC diagnostic pop