1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2020 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
29 #include "tree-pretty-print.h"
30 #include "stor-layout.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
34 #include "internal-fn.h"
35 #include "gomp-constants.h"
37 #include "fold-const.h"
39 /* Disable warnings about quoting issues in the pp_xxx calls below
40 that (intentionally) don't follow GCC diagnostic conventions. */
42 # pragma GCC diagnostic push
43 # pragma GCC diagnostic ignored "-Wformat-diag"
46 /* Local functions, macros and variables. */
47 static const char *op_symbol (const_tree
);
48 static void newline_and_indent (pretty_printer
*, int);
49 static void maybe_init_pretty_print (FILE *);
50 static void print_struct_decl (pretty_printer
*, const_tree
, int, dump_flags_t
);
51 static void do_niy (pretty_printer
*, const_tree
, dump_flags_t
);
53 #define INDENT(SPACE) do { \
54 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
56 #define NIY do_niy (pp, node, flags)
58 static pretty_printer
*tree_pp
;
60 /* Try to print something for an unknown tree code. */
63 do_niy (pretty_printer
*pp
, const_tree node
, dump_flags_t flags
)
67 pp_string (pp
, "<<< Unknown tree: ");
68 pp_string (pp
, get_tree_code_name (TREE_CODE (node
)));
72 len
= TREE_OPERAND_LENGTH (node
);
73 for (i
= 0; i
< len
; ++i
)
75 newline_and_indent (pp
, 2);
76 dump_generic_node (pp
, TREE_OPERAND (node
, i
), 2, flags
, false);
80 pp_string (pp
, " >>>");
83 /* Debugging function to print out a generic expression. */
86 debug_generic_expr (tree t
)
88 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
89 fprintf (stderr
, "\n");
92 /* Debugging function to print out a generic statement. */
95 debug_generic_stmt (tree t
)
97 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
98 fprintf (stderr
, "\n");
101 /* Debugging function to print out a chain of trees . */
104 debug_tree_chain (tree t
)
110 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
111 fprintf (stderr
, " ");
115 fprintf (stderr
, "... [cycled back to ");
116 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
117 fprintf (stderr
, "]");
121 fprintf (stderr
, "\n");
124 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
126 print_generic_decl (FILE *file
, tree decl
, dump_flags_t flags
)
128 maybe_init_pretty_print (file
);
129 print_declaration (tree_pp
, decl
, 2, flags
);
130 pp_write_text_to_stream (tree_pp
);
133 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
134 to show in the dump. See TDF_* in dumpfile.h. */
137 print_generic_stmt (FILE *file
, tree t
, dump_flags_t flags
)
139 maybe_init_pretty_print (file
);
140 dump_generic_node (tree_pp
, t
, 0, flags
, true);
141 pp_newline_and_flush (tree_pp
);
144 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
145 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
149 print_generic_stmt_indented (FILE *file
, tree t
, dump_flags_t flags
, int indent
)
153 maybe_init_pretty_print (file
);
155 for (i
= 0; i
< indent
; i
++)
157 dump_generic_node (tree_pp
, t
, indent
, flags
, true);
158 pp_newline_and_flush (tree_pp
);
161 /* Print a single expression T on file FILE. FLAGS specifies details to show
162 in the dump. See TDF_* in dumpfile.h. */
165 print_generic_expr (FILE *file
, tree t
, dump_flags_t flags
)
167 maybe_init_pretty_print (file
);
168 dump_generic_node (tree_pp
, t
, 0, flags
, false);
172 /* Print a single expression T to string, and return it. */
175 print_generic_expr_to_str (tree t
)
178 dump_generic_node (&pp
, t
, 0, TDF_VOPS
|TDF_MEMSYMS
, false);
179 return xstrdup (pp_formatted_text (&pp
));
182 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
183 in it are replaced with Dxxxx, as long as they are at the start or
184 preceded by $ and at the end or followed by $. See make_fancy_name
188 dump_fancy_name (pretty_printer
*pp
, tree name
)
191 int length
= IDENTIFIER_LENGTH (name
);
192 const char *n
= IDENTIFIER_POINTER (name
);
199 && (n
== IDENTIFIER_POINTER (name
) || n
[-1] == '$'))
202 while (ISDIGIT (n
[l
]))
204 if (n
[l
] == '\0' || n
[l
] == '$')
217 pp_tree_identifier (pp
, name
);
221 char *str
= XNEWVEC (char, length
+ 1);
224 q
= n
= IDENTIFIER_POINTER (name
);
231 && (q
== IDENTIFIER_POINTER (name
) || q
[-1] == '$'))
234 while (ISDIGIT (q
[l
]))
236 if (q
[l
] == '\0' || q
[l
] == '$')
238 memcpy (p
, n
, q
- n
);
239 memcpy (p
+ (q
- n
), "Dxxxx", 5);
249 memcpy (p
, n
, IDENTIFIER_LENGTH (name
) - (n
- IDENTIFIER_POINTER (name
)));
251 if (pp_translate_identifiers (pp
))
253 const char *text
= identifier_to_locale (str
);
254 pp_append_text (pp
, text
, text
+ strlen (text
));
257 pp_append_text (pp
, str
, str
+ length
);
261 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
265 dump_decl_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
267 tree name
= DECL_NAME (node
);
270 if ((flags
& TDF_ASMNAME
)
271 && HAS_DECL_ASSEMBLER_NAME_P (node
)
272 && DECL_ASSEMBLER_NAME_SET_P (node
))
273 pp_tree_identifier (pp
, DECL_ASSEMBLER_NAME_RAW (node
));
274 /* For -fcompare-debug don't dump DECL_NAMELESS names at all,
275 -g might have created more fancy names and their indexes
276 could get out of sync. Usually those should be DECL_IGNORED_P
277 too, SRA can create even non-DECL_IGNORED_P DECL_NAMELESS fancy
278 names, let's hope those never get out of sync after doing the
279 dump_fancy_name sanitization. */
280 else if ((flags
& TDF_COMPARE_DEBUG
)
281 && DECL_NAMELESS (node
)
282 && DECL_IGNORED_P (node
))
284 /* For DECL_NAMELESS names look for embedded uids in the
285 names and sanitize them for TDF_NOUID. */
286 else if ((flags
& TDF_NOUID
) && DECL_NAMELESS (node
))
287 dump_fancy_name (pp
, name
);
289 pp_tree_identifier (pp
, name
);
291 char uid_sep
= (flags
& TDF_GIMPLE
) ? '_' : '.';
292 if ((flags
& TDF_UID
) || name
== NULL_TREE
)
294 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
295 pp_printf (pp
, "L%c%d", uid_sep
, (int) LABEL_DECL_UID (node
));
296 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
298 if (flags
& TDF_NOUID
)
299 pp_string (pp
, "D#xxxx");
301 pp_printf (pp
, "D#%i", DEBUG_TEMP_UID (node
));
305 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
306 if (flags
& TDF_NOUID
)
307 pp_printf (pp
, "%c.xxxx", c
);
309 pp_printf (pp
, "%c%c%u", c
, uid_sep
, DECL_UID (node
));
312 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
314 if (flags
& TDF_NOUID
)
315 pp_printf (pp
, "ptD.xxxx");
317 pp_printf (pp
, "ptD.%u", DECL_PT_UID (node
));
321 /* Like the above, but used for pretty printing function calls. */
324 dump_function_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
326 if (CONVERT_EXPR_P (node
))
327 node
= TREE_OPERAND (node
, 0);
328 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
329 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
331 dump_decl_name (pp
, node
, flags
);
334 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
335 FLAGS are as in dump_generic_node. */
338 dump_function_declaration (pretty_printer
*pp
, tree node
,
339 int spc
, dump_flags_t flags
)
341 bool wrote_arg
= false;
347 /* Print the argument types. */
348 arg
= TYPE_ARG_TYPES (node
);
349 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
357 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
358 arg
= TREE_CHAIN (arg
);
361 /* Drop the trailing void_type_node if we had any previous argument. */
362 if (arg
== void_list_node
&& !wrote_arg
)
363 pp_string (pp
, "void");
364 /* Properly dump vararg function types. */
365 else if (!arg
&& wrote_arg
)
366 pp_string (pp
, ", ...");
367 /* Avoid printing any arg for unprototyped functions. */
372 /* Dump the domain associated with an array. */
375 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, dump_flags_t flags
)
377 pp_left_bracket (pp
);
380 tree min
= TYPE_MIN_VALUE (domain
);
381 tree max
= TYPE_MAX_VALUE (domain
);
384 && integer_zerop (min
)
385 && tree_fits_shwi_p (max
))
386 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
390 dump_generic_node (pp
, min
, spc
, flags
, false);
393 dump_generic_node (pp
, max
, spc
, flags
, false);
397 pp_string (pp
, "<unknown>");
398 pp_right_bracket (pp
);
402 /* Dump OpenMP iterators ITER. */
405 dump_omp_iterators (pretty_printer
*pp
, tree iter
, int spc
, dump_flags_t flags
)
407 pp_string (pp
, "iterator(");
408 for (tree it
= iter
; it
; it
= TREE_CHAIN (it
))
411 pp_string (pp
, ", ");
412 dump_generic_node (pp
, TREE_TYPE (TREE_VEC_ELT (it
, 0)), spc
, flags
,
415 dump_generic_node (pp
, TREE_VEC_ELT (it
, 0), spc
, flags
, false);
417 dump_generic_node (pp
, TREE_VEC_ELT (it
, 1), spc
, flags
, false);
419 dump_generic_node (pp
, TREE_VEC_ELT (it
, 2), spc
, flags
, false);
421 dump_generic_node (pp
, TREE_VEC_ELT (it
, 3), spc
, flags
, false);
427 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
428 dump_generic_node. */
431 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
434 const char *modifier
= NULL
;
435 switch (OMP_CLAUSE_CODE (clause
))
437 case OMP_CLAUSE_PRIVATE
:
440 case OMP_CLAUSE_SHARED
:
443 case OMP_CLAUSE_FIRSTPRIVATE
:
444 name
= "firstprivate";
446 case OMP_CLAUSE_LASTPRIVATE
:
447 name
= "lastprivate";
448 if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clause
))
449 modifier
= "conditional:";
451 case OMP_CLAUSE_COPYIN
:
454 case OMP_CLAUSE_COPYPRIVATE
:
455 name
= "copyprivate";
457 case OMP_CLAUSE_UNIFORM
:
460 case OMP_CLAUSE_USE_DEVICE_PTR
:
461 name
= "use_device_ptr";
462 if (OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT (clause
))
463 modifier
= "if_present:";
465 case OMP_CLAUSE_USE_DEVICE_ADDR
:
466 name
= "use_device_addr";
468 case OMP_CLAUSE_IS_DEVICE_PTR
:
469 name
= "is_device_ptr";
471 case OMP_CLAUSE_INCLUSIVE
:
474 case OMP_CLAUSE_EXCLUSIVE
:
477 case OMP_CLAUSE__LOOPTEMP_
:
480 case OMP_CLAUSE__REDUCTEMP_
:
481 name
= "_reductemp_";
483 case OMP_CLAUSE__CONDTEMP_
:
486 case OMP_CLAUSE__SCANTEMP_
:
489 case OMP_CLAUSE_TO_DECLARE
:
492 case OMP_CLAUSE_LINK
:
495 case OMP_CLAUSE_NONTEMPORAL
:
496 name
= "nontemporal";
499 pp_string (pp
, name
);
502 pp_string (pp
, modifier
);
503 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
508 case OMP_CLAUSE_TASK_REDUCTION
:
509 case OMP_CLAUSE_IN_REDUCTION
:
510 pp_string (pp
, OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_IN_REDUCTION
513 case OMP_CLAUSE_REDUCTION
:
514 pp_string (pp
, "reduction(");
515 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_REDUCTION
)
517 if (OMP_CLAUSE_REDUCTION_TASK (clause
))
518 pp_string (pp
, "task,");
519 else if (OMP_CLAUSE_REDUCTION_INSCAN (clause
))
520 pp_string (pp
, "inscan,");
522 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
525 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
528 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
534 pp_string (pp
, "if(");
535 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
537 case ERROR_MARK
: break;
538 case VOID_CST
: pp_string (pp
, "cancel:"); break;
539 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
540 case OMP_SIMD
: pp_string (pp
, "simd:"); break;
541 case OMP_TASK
: pp_string (pp
, "task:"); break;
542 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
543 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
544 case OMP_TARGET
: pp_string (pp
, "target:"); break;
545 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
546 case OMP_TARGET_ENTER_DATA
:
547 pp_string (pp
, "target enter data:"); break;
548 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
549 default: gcc_unreachable ();
551 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
556 case OMP_CLAUSE_NUM_THREADS
:
557 pp_string (pp
, "num_threads(");
558 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
563 case OMP_CLAUSE_NOWAIT
:
564 pp_string (pp
, "nowait");
566 case OMP_CLAUSE_ORDERED
:
567 pp_string (pp
, "ordered");
568 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
571 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
577 case OMP_CLAUSE_DEFAULT
:
578 pp_string (pp
, "default(");
579 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
581 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
583 case OMP_CLAUSE_DEFAULT_SHARED
:
584 pp_string (pp
, "shared");
586 case OMP_CLAUSE_DEFAULT_NONE
:
587 pp_string (pp
, "none");
589 case OMP_CLAUSE_DEFAULT_PRIVATE
:
590 pp_string (pp
, "private");
592 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
593 pp_string (pp
, "firstprivate");
595 case OMP_CLAUSE_DEFAULT_PRESENT
:
596 pp_string (pp
, "present");
604 case OMP_CLAUSE_SCHEDULE
:
605 pp_string (pp
, "schedule(");
606 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
607 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
608 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
610 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
611 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
612 pp_string (pp
, "monotonic");
614 pp_string (pp
, "nonmonotonic");
615 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
620 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
621 pp_string (pp
, "simd:");
623 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
625 case OMP_CLAUSE_SCHEDULE_STATIC
:
626 pp_string (pp
, "static");
628 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
629 pp_string (pp
, "dynamic");
631 case OMP_CLAUSE_SCHEDULE_GUIDED
:
632 pp_string (pp
, "guided");
634 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
635 pp_string (pp
, "runtime");
637 case OMP_CLAUSE_SCHEDULE_AUTO
:
638 pp_string (pp
, "auto");
643 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
646 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
652 case OMP_CLAUSE_UNTIED
:
653 pp_string (pp
, "untied");
656 case OMP_CLAUSE_COLLAPSE
:
657 pp_string (pp
, "collapse(");
658 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
663 case OMP_CLAUSE_FINAL
:
664 pp_string (pp
, "final(");
665 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
670 case OMP_CLAUSE_MERGEABLE
:
671 pp_string (pp
, "mergeable");
674 case OMP_CLAUSE_LINEAR
:
675 pp_string (pp
, "linear(");
676 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
678 case OMP_CLAUSE_LINEAR_DEFAULT
:
680 case OMP_CLAUSE_LINEAR_REF
:
681 pp_string (pp
, "ref(");
683 case OMP_CLAUSE_LINEAR_VAL
:
684 pp_string (pp
, "val(");
686 case OMP_CLAUSE_LINEAR_UVAL
:
687 pp_string (pp
, "uval(");
692 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
694 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
697 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
702 case OMP_CLAUSE_ALIGNED
:
703 pp_string (pp
, "aligned(");
704 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
706 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
709 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
715 case OMP_CLAUSE_ALLOCATE
:
716 pp_string (pp
, "allocate(");
717 if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause
))
719 dump_generic_node (pp
, OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause
),
723 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
728 case OMP_CLAUSE_DEPEND
:
729 pp_string (pp
, "depend(");
730 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
732 case OMP_CLAUSE_DEPEND_DEPOBJ
:
735 case OMP_CLAUSE_DEPEND_IN
:
738 case OMP_CLAUSE_DEPEND_OUT
:
741 case OMP_CLAUSE_DEPEND_INOUT
:
744 case OMP_CLAUSE_DEPEND_MUTEXINOUTSET
:
745 name
= "mutexinoutset";
747 case OMP_CLAUSE_DEPEND_SOURCE
:
748 pp_string (pp
, "source)");
750 case OMP_CLAUSE_DEPEND_LAST
:
751 name
= "__internal__";
753 case OMP_CLAUSE_DEPEND_SINK
:
754 pp_string (pp
, "sink:");
755 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
756 if (TREE_CODE (t
) == TREE_LIST
)
758 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
759 if (TREE_PURPOSE (t
) != integer_zero_node
)
761 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
765 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
779 tree t
= OMP_CLAUSE_DECL (clause
);
780 if (TREE_CODE (t
) == TREE_LIST
782 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
784 dump_omp_iterators (pp
, TREE_PURPOSE (t
), spc
, flags
);
788 pp_string (pp
, name
);
790 dump_generic_node (pp
, t
, spc
, flags
, false);
796 pp_string (pp
, "map(");
797 switch (OMP_CLAUSE_MAP_KIND (clause
))
800 case GOMP_MAP_POINTER
:
801 pp_string (pp
, "alloc");
803 case GOMP_MAP_IF_PRESENT
:
804 pp_string (pp
, "no_alloc");
807 case GOMP_MAP_TO_PSET
:
808 pp_string (pp
, "to");
811 pp_string (pp
, "from");
813 case GOMP_MAP_TOFROM
:
814 pp_string (pp
, "tofrom");
816 case GOMP_MAP_FORCE_ALLOC
:
817 pp_string (pp
, "force_alloc");
819 case GOMP_MAP_FORCE_TO
:
820 pp_string (pp
, "force_to");
822 case GOMP_MAP_FORCE_FROM
:
823 pp_string (pp
, "force_from");
825 case GOMP_MAP_FORCE_TOFROM
:
826 pp_string (pp
, "force_tofrom");
828 case GOMP_MAP_FORCE_PRESENT
:
829 pp_string (pp
, "force_present");
831 case GOMP_MAP_DELETE
:
832 pp_string (pp
, "delete");
834 case GOMP_MAP_FORCE_DEVICEPTR
:
835 pp_string (pp
, "force_deviceptr");
837 case GOMP_MAP_ALWAYS_TO
:
838 pp_string (pp
, "always,to");
840 case GOMP_MAP_ALWAYS_FROM
:
841 pp_string (pp
, "always,from");
843 case GOMP_MAP_ALWAYS_TOFROM
:
844 pp_string (pp
, "always,tofrom");
846 case GOMP_MAP_RELEASE
:
847 pp_string (pp
, "release");
849 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
850 pp_string (pp
, "firstprivate");
852 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
853 pp_string (pp
, "firstprivate ref");
855 case GOMP_MAP_STRUCT
:
856 pp_string (pp
, "struct");
858 case GOMP_MAP_ALWAYS_POINTER
:
859 pp_string (pp
, "always_pointer");
861 case GOMP_MAP_DEVICE_RESIDENT
:
862 pp_string (pp
, "device_resident");
865 pp_string (pp
, "link");
867 case GOMP_MAP_ATTACH
:
868 pp_string (pp
, "attach");
870 case GOMP_MAP_DETACH
:
871 pp_string (pp
, "detach");
873 case GOMP_MAP_FORCE_DETACH
:
874 pp_string (pp
, "force_detach");
876 case GOMP_MAP_ATTACH_DETACH
:
877 pp_string (pp
, "attach_detach");
883 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
886 if (OMP_CLAUSE_SIZE (clause
))
888 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
889 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
891 case GOMP_MAP_POINTER
:
892 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
893 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
894 case GOMP_MAP_ALWAYS_POINTER
:
895 pp_string (pp
, " [pointer assign, bias: ");
897 case GOMP_MAP_TO_PSET
:
898 pp_string (pp
, " [pointer set, len: ");
900 case GOMP_MAP_ATTACH
:
901 case GOMP_MAP_DETACH
:
902 case GOMP_MAP_FORCE_DETACH
:
903 case GOMP_MAP_ATTACH_DETACH
:
904 pp_string (pp
, " [bias: ");
907 pp_string (pp
, " [len: ");
910 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
912 pp_right_bracket (pp
);
917 case OMP_CLAUSE_FROM
:
918 pp_string (pp
, "from(");
919 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
921 goto print_clause_size
;
924 pp_string (pp
, "to(");
925 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
927 goto print_clause_size
;
929 case OMP_CLAUSE__CACHE_
:
931 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
933 goto print_clause_size
;
935 case OMP_CLAUSE_NUM_TEAMS
:
936 pp_string (pp
, "num_teams(");
937 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
942 case OMP_CLAUSE_THREAD_LIMIT
:
943 pp_string (pp
, "thread_limit(");
944 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
949 case OMP_CLAUSE_DEVICE
:
950 pp_string (pp
, "device(");
951 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
956 case OMP_CLAUSE_DIST_SCHEDULE
:
957 pp_string (pp
, "dist_schedule(static");
958 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
961 dump_generic_node (pp
,
962 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
968 case OMP_CLAUSE_PROC_BIND
:
969 pp_string (pp
, "proc_bind(");
970 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
972 case OMP_CLAUSE_PROC_BIND_MASTER
:
973 pp_string (pp
, "master");
975 case OMP_CLAUSE_PROC_BIND_CLOSE
:
976 pp_string (pp
, "close");
978 case OMP_CLAUSE_PROC_BIND_SPREAD
:
979 pp_string (pp
, "spread");
987 case OMP_CLAUSE_DEVICE_TYPE
:
988 pp_string (pp
, "device_type(");
989 switch (OMP_CLAUSE_DEVICE_TYPE_KIND (clause
))
991 case OMP_CLAUSE_DEVICE_TYPE_HOST
:
992 pp_string (pp
, "host");
994 case OMP_CLAUSE_DEVICE_TYPE_NOHOST
:
995 pp_string (pp
, "nohost");
997 case OMP_CLAUSE_DEVICE_TYPE_ANY
:
998 pp_string (pp
, "any");
1003 pp_right_paren (pp
);
1006 case OMP_CLAUSE_SAFELEN
:
1007 pp_string (pp
, "safelen(");
1008 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
1010 pp_right_paren (pp
);
1013 case OMP_CLAUSE_SIMDLEN
:
1014 pp_string (pp
, "simdlen(");
1015 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
1017 pp_right_paren (pp
);
1020 case OMP_CLAUSE_PRIORITY
:
1021 pp_string (pp
, "priority(");
1022 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
1024 pp_right_paren (pp
);
1027 case OMP_CLAUSE_GRAINSIZE
:
1028 pp_string (pp
, "grainsize(");
1029 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
1031 pp_right_paren (pp
);
1034 case OMP_CLAUSE_NUM_TASKS
:
1035 pp_string (pp
, "num_tasks(");
1036 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
1038 pp_right_paren (pp
);
1041 case OMP_CLAUSE_HINT
:
1042 pp_string (pp
, "hint(");
1043 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
1045 pp_right_paren (pp
);
1048 case OMP_CLAUSE_DEFAULTMAP
:
1049 pp_string (pp
, "defaultmap(");
1050 switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (clause
))
1052 case OMP_CLAUSE_DEFAULTMAP_ALLOC
:
1053 pp_string (pp
, "alloc");
1055 case OMP_CLAUSE_DEFAULTMAP_TO
:
1056 pp_string (pp
, "to");
1058 case OMP_CLAUSE_DEFAULTMAP_FROM
:
1059 pp_string (pp
, "from");
1061 case OMP_CLAUSE_DEFAULTMAP_TOFROM
:
1062 pp_string (pp
, "tofrom");
1064 case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE
:
1065 pp_string (pp
, "firstprivate");
1067 case OMP_CLAUSE_DEFAULTMAP_NONE
:
1068 pp_string (pp
, "none");
1070 case OMP_CLAUSE_DEFAULTMAP_DEFAULT
:
1071 pp_string (pp
, "default");
1076 switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (clause
))
1078 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED
:
1080 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR
:
1081 pp_string (pp
, ":scalar");
1083 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE
:
1084 pp_string (pp
, ":aggregate");
1086 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE
:
1087 pp_string (pp
, ":allocatable");
1089 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER
:
1090 pp_string (pp
, ":pointer");
1095 pp_right_paren (pp
);
1098 case OMP_CLAUSE_ORDER
:
1099 pp_string (pp
, "order(concurrent)");
1102 case OMP_CLAUSE_BIND
:
1103 pp_string (pp
, "bind(");
1104 switch (OMP_CLAUSE_BIND_KIND (clause
))
1106 case OMP_CLAUSE_BIND_TEAMS
:
1107 pp_string (pp
, "teams");
1109 case OMP_CLAUSE_BIND_PARALLEL
:
1110 pp_string (pp
, "parallel");
1112 case OMP_CLAUSE_BIND_THREAD
:
1113 pp_string (pp
, "thread");
1118 pp_right_paren (pp
);
1121 case OMP_CLAUSE__SIMDUID_
:
1122 pp_string (pp
, "_simduid_(");
1123 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
1125 pp_right_paren (pp
);
1128 case OMP_CLAUSE__SIMT_
:
1129 pp_string (pp
, "_simt_");
1132 case OMP_CLAUSE_GANG
:
1133 pp_string (pp
, "gang");
1134 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
1136 pp_string (pp
, "(num: ");
1137 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
1140 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
1142 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
1146 pp_string (pp
, "static:");
1147 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
1148 == integer_minus_one_node
)
1149 pp_character (pp
, '*');
1151 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
1154 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
1155 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
1156 pp_right_paren (pp
);
1159 case OMP_CLAUSE_ASYNC
:
1160 pp_string (pp
, "async");
1161 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
1163 pp_character(pp
, '(');
1164 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
1166 pp_character(pp
, ')');
1170 case OMP_CLAUSE_AUTO
:
1171 case OMP_CLAUSE_SEQ
:
1172 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
1175 case OMP_CLAUSE_WAIT
:
1176 pp_string (pp
, "wait(");
1177 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
1179 pp_character(pp
, ')');
1182 case OMP_CLAUSE_WORKER
:
1183 pp_string (pp
, "worker");
1184 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
1187 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
1189 pp_right_paren (pp
);
1193 case OMP_CLAUSE_VECTOR
:
1194 pp_string (pp
, "vector");
1195 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
1198 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
1200 pp_right_paren (pp
);
1204 case OMP_CLAUSE_NUM_GANGS
:
1205 pp_string (pp
, "num_gangs(");
1206 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
1208 pp_character (pp
, ')');
1211 case OMP_CLAUSE_NUM_WORKERS
:
1212 pp_string (pp
, "num_workers(");
1213 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
1215 pp_character (pp
, ')');
1218 case OMP_CLAUSE_VECTOR_LENGTH
:
1219 pp_string (pp
, "vector_length(");
1220 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
1222 pp_character (pp
, ')');
1225 case OMP_CLAUSE_INBRANCH
:
1226 pp_string (pp
, "inbranch");
1228 case OMP_CLAUSE_NOTINBRANCH
:
1229 pp_string (pp
, "notinbranch");
1231 case OMP_CLAUSE_FOR
:
1232 pp_string (pp
, "for");
1234 case OMP_CLAUSE_PARALLEL
:
1235 pp_string (pp
, "parallel");
1237 case OMP_CLAUSE_SECTIONS
:
1238 pp_string (pp
, "sections");
1240 case OMP_CLAUSE_TASKGROUP
:
1241 pp_string (pp
, "taskgroup");
1243 case OMP_CLAUSE_NOGROUP
:
1244 pp_string (pp
, "nogroup");
1246 case OMP_CLAUSE_THREADS
:
1247 pp_string (pp
, "threads");
1249 case OMP_CLAUSE_SIMD
:
1250 pp_string (pp
, "simd");
1252 case OMP_CLAUSE_INDEPENDENT
:
1253 pp_string (pp
, "independent");
1255 case OMP_CLAUSE_TILE
:
1256 pp_string (pp
, "tile(");
1257 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1259 pp_right_paren (pp
);
1262 case OMP_CLAUSE_IF_PRESENT
:
1263 pp_string (pp
, "if_present");
1265 case OMP_CLAUSE_FINALIZE
:
1266 pp_string (pp
, "finalize");
1275 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1276 dump_generic_node. */
1279 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
1287 dump_omp_clause (pp
, clause
, spc
, flags
);
1288 clause
= OMP_CLAUSE_CHAIN (clause
);
1296 /* Dump location LOC to PP. */
1299 dump_location (pretty_printer
*pp
, location_t loc
)
1301 expanded_location xloc
= expand_location (loc
);
1303 pp_left_bracket (pp
);
1306 pp_string (pp
, xloc
.file
);
1307 pp_string (pp
, ":");
1309 pp_decimal_int (pp
, xloc
.line
);
1311 pp_decimal_int (pp
, xloc
.column
);
1312 pp_string (pp
, "] ");
1316 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1317 dump_generic_node. */
1320 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, dump_flags_t flags
)
1324 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1326 if (flags
& TDF_ADDRESS
)
1327 pp_printf (pp
, "[%p] ", (void *) block
);
1329 if (TREE_ASM_WRITTEN (block
))
1330 pp_string (pp
, "[written] ");
1332 if (flags
& TDF_SLIM
)
1335 if (BLOCK_SOURCE_LOCATION (block
))
1336 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1338 newline_and_indent (pp
, spc
+ 2);
1340 if (BLOCK_SUPERCONTEXT (block
))
1342 pp_string (pp
, "SUPERCONTEXT: ");
1343 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1344 flags
| TDF_SLIM
, false);
1345 newline_and_indent (pp
, spc
+ 2);
1348 if (BLOCK_SUBBLOCKS (block
))
1350 pp_string (pp
, "SUBBLOCKS: ");
1351 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1353 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1356 newline_and_indent (pp
, spc
+ 2);
1359 if (BLOCK_CHAIN (block
))
1361 pp_string (pp
, "SIBLINGS: ");
1362 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1364 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1367 newline_and_indent (pp
, spc
+ 2);
1370 if (BLOCK_VARS (block
))
1372 pp_string (pp
, "VARS: ");
1373 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1375 dump_generic_node (pp
, t
, 0, flags
, false);
1378 newline_and_indent (pp
, spc
+ 2);
1381 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1384 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1386 pp_string (pp
, "NONLOCALIZED_VARS: ");
1387 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1389 dump_generic_node (pp
, t
, 0, flags
, false);
1392 newline_and_indent (pp
, spc
+ 2);
1395 if (BLOCK_ABSTRACT_ORIGIN (block
))
1397 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1398 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1399 flags
| TDF_SLIM
, false);
1400 newline_and_indent (pp
, spc
+ 2);
1403 if (BLOCK_FRAGMENT_ORIGIN (block
))
1405 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1406 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1407 flags
| TDF_SLIM
, false);
1408 newline_and_indent (pp
, spc
+ 2);
1411 if (BLOCK_FRAGMENT_CHAIN (block
))
1413 pp_string (pp
, "FRAGMENT_CHAIN: ");
1414 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1416 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1419 newline_and_indent (pp
, spc
+ 2);
1423 /* Dump #pragma omp atomic memory order clause. */
1426 dump_omp_atomic_memory_order (pretty_printer
*pp
, enum omp_memory_order mo
)
1430 case OMP_MEMORY_ORDER_RELAXED
:
1431 pp_string (pp
, " relaxed");
1433 case OMP_MEMORY_ORDER_SEQ_CST
:
1434 pp_string (pp
, " seq_cst");
1436 case OMP_MEMORY_ORDER_ACQ_REL
:
1437 pp_string (pp
, " acq_rel");
1439 case OMP_MEMORY_ORDER_ACQUIRE
:
1440 pp_string (pp
, " acquire");
1442 case OMP_MEMORY_ORDER_RELEASE
:
1443 pp_string (pp
, " release");
1445 case OMP_MEMORY_ORDER_UNSPECIFIED
:
1452 /* Helper to dump a MEM_REF node. */
1455 dump_mem_ref (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
)
1457 if (TREE_CODE (node
) == MEM_REF
&& (flags
& TDF_GIMPLE
))
1459 pp_string (pp
, "__MEM <");
1460 dump_generic_node (pp
, TREE_TYPE (node
),
1461 spc
, flags
| TDF_SLIM
, false);
1462 if (TYPE_ALIGN (TREE_TYPE (node
))
1463 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
1465 pp_string (pp
, ", ");
1466 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
1469 pp_string (pp
, " (");
1470 if (TREE_TYPE (TREE_OPERAND (node
, 0))
1471 != TREE_TYPE (TREE_OPERAND (node
, 1)))
1474 dump_generic_node (pp
, TREE_TYPE (TREE_OPERAND (node
, 1)),
1475 spc
, flags
| TDF_SLIM
, false);
1476 pp_right_paren (pp
);
1478 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1479 spc
, flags
| TDF_SLIM
, false);
1480 if (! integer_zerop (TREE_OPERAND (node
, 1)))
1482 pp_string (pp
, " + ");
1483 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1484 spc
, flags
| TDF_SLIM
, false);
1486 pp_right_paren (pp
);
1488 else if (TREE_CODE (node
) == MEM_REF
1489 && integer_zerop (TREE_OPERAND (node
, 1))
1490 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1491 infer them and MEM_ATTR caching will share MEM_REFs
1492 with differently-typed op0s. */
1493 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1494 /* Released SSA_NAMES have no TREE_TYPE. */
1495 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1496 /* Same pointer types, but ignoring POINTER_TYPE vs.
1498 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1499 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1500 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1501 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1502 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1503 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1504 /* Same value types ignoring qualifiers. */
1505 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1506 == TYPE_MAIN_VARIANT
1507 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1508 && (!(flags
& TDF_ALIAS
)
1509 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1511 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1513 /* Enclose pointers to arrays in parentheses. */
1514 tree op0
= TREE_OPERAND (node
, 0);
1515 tree op0type
= TREE_TYPE (op0
);
1516 if (POINTER_TYPE_P (op0type
)
1517 && TREE_CODE (TREE_TYPE (op0type
)) == ARRAY_TYPE
)
1520 dump_generic_node (pp
, op0
, spc
, flags
, false);
1521 if (POINTER_TYPE_P (op0type
)
1522 && TREE_CODE (TREE_TYPE (op0type
)) == ARRAY_TYPE
)
1523 pp_right_paren (pp
);
1526 dump_generic_node (pp
,
1527 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1532 pp_string (pp
, "MEM");
1534 tree nodetype
= TREE_TYPE (node
);
1535 tree op0
= TREE_OPERAND (node
, 0);
1536 tree op1
= TREE_OPERAND (node
, 1);
1537 tree op1type
= TYPE_MAIN_VARIANT (TREE_TYPE (op1
));
1539 tree op0size
= TYPE_SIZE (nodetype
);
1540 tree op1size
= TYPE_SIZE (TREE_TYPE (op1type
));
1542 if (!op0size
|| !op1size
1543 || !operand_equal_p (op0size
, op1size
, 0))
1545 pp_string (pp
, " <");
1546 /* If the size of the type of the operand is not the same
1547 as the size of the MEM_REF expression include the type
1548 of the latter similar to the TDF_GIMPLE output to make
1549 it clear how many bytes of memory are being accessed. */
1550 dump_generic_node (pp
, nodetype
, spc
, flags
| TDF_SLIM
, false);
1551 pp_string (pp
, "> ");
1554 pp_string (pp
, "[(");
1555 dump_generic_node (pp
, op1type
, spc
, flags
| TDF_SLIM
, false);
1556 pp_right_paren (pp
);
1557 dump_generic_node (pp
, op0
, spc
, flags
, false);
1558 if (!integer_zerop (op1
))
1560 pp_string (pp
, " + ");
1561 dump_generic_node (pp
, op1
, spc
, flags
, false);
1563 if (TREE_CODE (node
) == TARGET_MEM_REF
)
1565 tree tmp
= TMR_INDEX2 (node
);
1568 pp_string (pp
, " + ");
1569 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1571 tmp
= TMR_INDEX (node
);
1574 pp_string (pp
, " + ");
1575 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1576 tmp
= TMR_STEP (node
);
1577 pp_string (pp
, " * ");
1579 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1581 pp_string (pp
, "1");
1584 if ((flags
& TDF_ALIAS
)
1585 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1587 pp_string (pp
, " clique ");
1588 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1589 pp_string (pp
, " base ");
1590 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1592 pp_right_bracket (pp
);
1596 /* Helper function for dump_generic_node. Dump INIT or COND expression for
1597 OpenMP loop non-rectangular iterators. */
1600 dump_omp_loop_non_rect_expr (pretty_printer
*pp
, tree node
, int spc
,
1603 gcc_assert (TREE_CODE (node
) == TREE_VEC
);
1604 dump_generic_node (pp
, TREE_VEC_ELT (node
, 0), spc
, flags
, false);
1605 pp_string (pp
, " * ");
1606 if (op_prio (TREE_VEC_ELT (node
, 1)) <= op_code_prio (MULT_EXPR
))
1609 dump_generic_node (pp
, TREE_VEC_ELT (node
, 1), spc
, flags
, false);
1610 pp_right_paren (pp
);
1613 dump_generic_node (pp
, TREE_VEC_ELT (node
, 1), spc
, flags
, false);
1614 pp_string (pp
, " + ");
1615 if (op_prio (TREE_VEC_ELT (node
, 1)) <= op_code_prio (PLUS_EXPR
))
1618 dump_generic_node (pp
, TREE_VEC_ELT (node
, 2), spc
, flags
, false);
1619 pp_right_paren (pp
);
1622 dump_generic_node (pp
, TREE_VEC_ELT (node
, 2), spc
, flags
, false);
1625 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1626 indent. FLAGS specifies details to show in the dump (see TDF_* in
1627 dumpfile.h). If IS_STMT is true, the object printed is considered
1628 to be a statement and it is terminated by ';' if appropriate. */
1631 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
,
1638 enum tree_code code
;
1640 if (node
== NULL_TREE
)
1643 is_expr
= EXPR_P (node
);
1645 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1646 pp_printf (pp
, "<&%p> ", (void *)node
);
1648 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1649 dump_location (pp
, EXPR_LOCATION (node
));
1651 code
= TREE_CODE (node
);
1655 pp_string (pp
, "<<< error >>>");
1658 case IDENTIFIER_NODE
:
1659 pp_tree_identifier (pp
, node
);
1663 while (node
&& node
!= error_mark_node
)
1665 if (TREE_PURPOSE (node
))
1667 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1670 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1671 node
= TREE_CHAIN (node
);
1672 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1681 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1687 if (TREE_VEC_LENGTH (node
) > 0)
1689 size_t len
= TREE_VEC_LENGTH (node
);
1690 for (i
= 0; i
< len
- 1; i
++)
1692 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1697 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1706 case FIXED_POINT_TYPE
:
1712 unsigned int quals
= TYPE_QUALS (node
);
1713 enum tree_code_class tclass
;
1715 if (quals
& TYPE_QUAL_ATOMIC
)
1716 pp_string (pp
, "atomic ");
1717 if (quals
& TYPE_QUAL_CONST
)
1718 pp_string (pp
, "const ");
1719 if (quals
& TYPE_QUAL_VOLATILE
)
1720 pp_string (pp
, "volatile ");
1721 if (quals
& TYPE_QUAL_RESTRICT
)
1722 pp_string (pp
, "restrict ");
1724 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1726 pp_string (pp
, "<address-space-");
1727 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1728 pp_string (pp
, "> ");
1731 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1733 if (tclass
== tcc_declaration
)
1735 if (DECL_NAME (node
))
1736 dump_decl_name (pp
, node
, flags
);
1738 pp_string (pp
, "<unnamed type decl>");
1740 else if (tclass
== tcc_type
)
1742 if (TYPE_NAME (node
))
1744 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1745 pp_tree_identifier (pp
, TYPE_NAME (node
));
1746 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1747 && DECL_NAME (TYPE_NAME (node
)))
1748 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1750 pp_string (pp
, "<unnamed type>");
1752 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1754 pp_string (pp
, "vector");
1756 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1757 pp_string (pp
, ") ");
1758 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1760 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1762 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1763 pp_string (pp
, (TYPE_UNSIGNED (node
)
1766 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1767 pp_string (pp
, (TYPE_UNSIGNED (node
)
1770 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1771 pp_string (pp
, (TYPE_UNSIGNED (node
)
1774 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1775 pp_string (pp
, (TYPE_UNSIGNED (node
)
1778 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1779 pp_string (pp
, (TYPE_UNSIGNED (node
)
1780 ? "unsigned long long"
1781 : "signed long long"));
1782 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1783 && pow2p_hwi (TYPE_PRECISION (node
)))
1785 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1786 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1787 pp_string (pp
, "_t");
1791 pp_string (pp
, (TYPE_UNSIGNED (node
)
1792 ? "<unnamed-unsigned:"
1793 : "<unnamed-signed:"));
1794 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1798 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1800 pp_string (pp
, "__complex__ ");
1801 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1803 else if (TREE_CODE (node
) == REAL_TYPE
)
1805 pp_string (pp
, "<float:");
1806 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1809 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1811 pp_string (pp
, "<fixed-point-");
1812 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1813 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1816 else if (TREE_CODE (node
) == BOOLEAN_TYPE
)
1818 pp_string (pp
, (TYPE_UNSIGNED (node
)
1819 ? "<unsigned-boolean:"
1820 : "<signed-boolean:"));
1821 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1824 else if (TREE_CODE (node
) == VOID_TYPE
)
1825 pp_string (pp
, "void");
1827 pp_string (pp
, "<unnamed type>");
1833 case REFERENCE_TYPE
:
1834 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1836 if (TREE_TYPE (node
) == NULL
)
1838 pp_string (pp
, str
);
1839 pp_string (pp
, "<null type>");
1841 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1843 tree fnode
= TREE_TYPE (node
);
1845 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1848 pp_string (pp
, str
);
1849 if (TYPE_IDENTIFIER (node
))
1850 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1851 else if (flags
& TDF_NOUID
)
1852 pp_printf (pp
, "<Txxxx>");
1854 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1856 pp_right_paren (pp
);
1857 dump_function_declaration (pp
, fnode
, spc
, flags
);
1861 unsigned int quals
= TYPE_QUALS (node
);
1863 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1865 pp_string (pp
, str
);
1867 if (quals
& TYPE_QUAL_CONST
)
1868 pp_string (pp
, " const");
1869 if (quals
& TYPE_QUAL_VOLATILE
)
1870 pp_string (pp
, " volatile");
1871 if (quals
& TYPE_QUAL_RESTRICT
)
1872 pp_string (pp
, " restrict");
1874 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1876 pp_string (pp
, " <address-space-");
1877 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1881 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1882 pp_string (pp
, " {ref-all}");
1891 case TARGET_MEM_REF
:
1892 dump_mem_ref (pp
, node
, spc
, flags
);
1897 unsigned int quals
= TYPE_QUALS (node
);
1900 if (quals
& TYPE_QUAL_ATOMIC
)
1901 pp_string (pp
, "atomic ");
1902 if (quals
& TYPE_QUAL_CONST
)
1903 pp_string (pp
, "const ");
1904 if (quals
& TYPE_QUAL_VOLATILE
)
1905 pp_string (pp
, "volatile ");
1907 /* Print the innermost component type. */
1908 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1909 tmp
= TREE_TYPE (tmp
))
1911 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1913 /* Print the dimensions. */
1914 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1915 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1921 case QUAL_UNION_TYPE
:
1923 unsigned int quals
= TYPE_QUALS (node
);
1925 if (quals
& TYPE_QUAL_ATOMIC
)
1926 pp_string (pp
, "atomic ");
1927 if (quals
& TYPE_QUAL_CONST
)
1928 pp_string (pp
, "const ");
1929 if (quals
& TYPE_QUAL_VOLATILE
)
1930 pp_string (pp
, "volatile ");
1932 /* Print the name of the structure. */
1933 if (TREE_CODE (node
) == RECORD_TYPE
)
1934 pp_string (pp
, "struct ");
1935 else if (TREE_CODE (node
) == UNION_TYPE
)
1936 pp_string (pp
, "union ");
1938 if (TYPE_NAME (node
))
1939 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1940 else if (!(flags
& TDF_SLIM
))
1941 /* FIXME: If we eliminate the 'else' above and attempt
1942 to show the fields for named types, we may get stuck
1943 following a cycle of pointers to structs. The alleged
1944 self-reference check in print_struct_decl will not detect
1945 cycles involving more than one pointer or struct type. */
1946 print_struct_decl (pp
, node
, spc
, flags
);
1955 if (flags
& TDF_GIMPLE
1956 && (POINTER_TYPE_P (TREE_TYPE (node
))
1957 || (TYPE_PRECISION (TREE_TYPE (node
))
1958 < TYPE_PRECISION (integer_type_node
))
1959 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1
1960 || tree_int_cst_sgn (node
) < 0))
1962 pp_string (pp
, "_Literal (");
1963 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1964 pp_string (pp
, ") ");
1966 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
1967 && ! (flags
& TDF_GIMPLE
))
1969 /* In the case of a pointer, one may want to divide by the
1970 size of the pointed-to type. Unfortunately, this not
1971 straightforward. The C front-end maps expressions
1976 in such a way that the two INTEGER_CST nodes for "5" have
1977 different values but identical types. In the latter
1978 case, the 5 is multiplied by sizeof (int) in c-common.c
1979 (pointer_int_sum) to convert it to a byte address, and
1980 yet the type of the node is left unchanged. Argh. What
1981 is consistent though is that the number value corresponds
1982 to bytes (UNITS) offset.
1984 NB: Neither of the following divisors can be trivially
1985 used to recover the original literal:
1987 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1988 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1989 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1990 pp_string (pp
, "B"); /* pseudo-unit */
1992 else if (tree_fits_shwi_p (node
))
1993 pp_wide_integer (pp
, tree_to_shwi (node
));
1994 else if (tree_fits_uhwi_p (node
))
1995 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1998 wide_int val
= wi::to_wide (node
);
2000 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
2005 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
2006 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
2008 if ((flags
& TDF_GIMPLE
)
2009 && ! (POINTER_TYPE_P (TREE_TYPE (node
))
2010 || (TYPE_PRECISION (TREE_TYPE (node
))
2011 < TYPE_PRECISION (integer_type_node
))
2012 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
2014 if (TYPE_UNSIGNED (TREE_TYPE (node
)))
2015 pp_character (pp
, 'u');
2016 if (TYPE_PRECISION (TREE_TYPE (node
))
2017 == TYPE_PRECISION (unsigned_type_node
))
2019 else if (TYPE_PRECISION (TREE_TYPE (node
))
2020 == TYPE_PRECISION (long_unsigned_type_node
))
2021 pp_character (pp
, 'l');
2022 else if (TYPE_PRECISION (TREE_TYPE (node
))
2023 == TYPE_PRECISION (long_long_unsigned_type_node
))
2024 pp_string (pp
, "ll");
2026 if (TREE_OVERFLOW (node
))
2027 pp_string (pp
, "(OVF)");
2031 pp_string (pp
, "POLY_INT_CST [");
2032 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, 0), spc
, flags
, false);
2033 for (unsigned int i
= 1; i
< NUM_POLY_INT_COEFFS
; ++i
)
2035 pp_string (pp
, ", ");
2036 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, i
),
2039 pp_string (pp
, "]");
2043 /* Code copied from print_node. */
2046 if (TREE_OVERFLOW (node
))
2047 pp_string (pp
, " overflow");
2049 d
= TREE_REAL_CST (node
);
2050 if (REAL_VALUE_ISINF (d
))
2051 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
2052 else if (REAL_VALUE_ISNAN (d
))
2053 pp_string (pp
, " Nan");
2057 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
2058 pp_string (pp
, string
);
2066 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
2067 pp_string (pp
, string
);
2072 pp_string (pp
, "__complex__ (");
2073 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
2074 pp_string (pp
, ", ");
2075 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
2076 pp_right_paren (pp
);
2081 pp_string (pp
, "\"");
2082 if (unsigned nbytes
= TREE_STRING_LENGTH (node
))
2083 pretty_print_string (pp
, TREE_STRING_POINTER (node
), nbytes
);
2084 pp_string (pp
, "\"");
2091 if (flags
& TDF_GIMPLE
)
2093 pp_string (pp
, "_Literal (");
2094 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2095 pp_string (pp
, ") ");
2097 pp_string (pp
, "{ ");
2098 unsigned HOST_WIDE_INT nunits
;
2099 if (!VECTOR_CST_NELTS (node
).is_constant (&nunits
))
2100 nunits
= vector_cst_encoded_nelts (node
);
2101 for (i
= 0; i
< nunits
; ++i
)
2104 pp_string (pp
, ", ");
2105 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
2108 if (!VECTOR_CST_NELTS (node
).is_constant ())
2109 pp_string (pp
, ", ...");
2110 pp_string (pp
, " }");
2116 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2118 if (TREE_CODE (node
) == METHOD_TYPE
)
2120 if (TYPE_METHOD_BASETYPE (node
))
2121 dump_generic_node (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
2124 pp_string (pp
, "<null method basetype>");
2125 pp_colon_colon (pp
);
2127 if (TYPE_IDENTIFIER (node
))
2128 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
2129 else if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
2130 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
2131 else if (flags
& TDF_NOUID
)
2132 pp_printf (pp
, "<Txxxx>");
2134 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
2135 dump_function_declaration (pp
, node
, spc
, flags
);
2140 dump_decl_name (pp
, node
, flags
);
2144 if (DECL_NAME (node
))
2145 dump_decl_name (pp
, node
, flags
);
2146 else if (LABEL_DECL_UID (node
) != -1)
2148 if (flags
& TDF_GIMPLE
)
2149 pp_printf (pp
, "L%d", (int) LABEL_DECL_UID (node
));
2151 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
2155 if (flags
& TDF_NOUID
)
2156 pp_string (pp
, "<D.xxxx>");
2159 if (flags
& TDF_GIMPLE
)
2160 pp_printf (pp
, "<D%u>", DECL_UID (node
));
2162 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
2168 if (DECL_IS_UNDECLARED_BUILTIN (node
))
2170 /* Don't print the declaration of built-in types. */
2173 if (DECL_NAME (node
))
2174 dump_decl_name (pp
, node
, flags
);
2175 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
2177 pp_string (pp
, (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
2178 ? "union" : "struct "));
2179 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2182 pp_string (pp
, "<anon>");
2188 case DEBUG_EXPR_DECL
:
2189 case NAMESPACE_DECL
:
2191 dump_decl_name (pp
, node
, flags
);
2195 pp_string (pp
, "<retval>");
2199 op0
= TREE_OPERAND (node
, 0);
2202 && (TREE_CODE (op0
) == INDIRECT_REF
2203 || (TREE_CODE (op0
) == MEM_REF
2204 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
2205 && integer_zerop (TREE_OPERAND (op0
, 1))
2206 /* Dump the types of INTEGER_CSTs explicitly, for we
2207 can't infer them and MEM_ATTR caching will share
2208 MEM_REFs with differently-typed op0s. */
2209 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
2210 /* Released SSA_NAMES have no TREE_TYPE. */
2211 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
2212 /* Same pointer types, but ignoring POINTER_TYPE vs.
2214 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2215 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2216 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2217 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2218 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2219 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2220 /* Same value types ignoring qualifiers. */
2221 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
2222 == TYPE_MAIN_VARIANT
2223 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
2224 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
2226 op0
= TREE_OPERAND (op0
, 0);
2229 if (op_prio (op0
) < op_prio (node
))
2231 dump_generic_node (pp
, op0
, spc
, flags
, false);
2232 if (op_prio (op0
) < op_prio (node
))
2233 pp_right_paren (pp
);
2234 pp_string (pp
, str
);
2235 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2236 op0
= component_ref_field_offset (node
);
2237 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
2239 pp_string (pp
, "{off: ");
2240 dump_generic_node (pp
, op0
, spc
, flags
, false);
2241 pp_right_brace (pp
);
2246 if (flags
& TDF_GIMPLE
)
2248 pp_string (pp
, "__BIT_FIELD_REF <");
2249 dump_generic_node (pp
, TREE_TYPE (node
),
2250 spc
, flags
| TDF_SLIM
, false);
2251 if (TYPE_ALIGN (TREE_TYPE (node
))
2252 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
2254 pp_string (pp
, ", ");
2255 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
2258 pp_string (pp
, " (");
2259 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
,
2260 flags
| TDF_SLIM
, false);
2261 pp_string (pp
, ", ");
2262 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
,
2263 flags
| TDF_SLIM
, false);
2264 pp_string (pp
, ", ");
2265 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
,
2266 flags
| TDF_SLIM
, false);
2267 pp_right_paren (pp
);
2271 pp_string (pp
, "BIT_FIELD_REF <");
2272 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2273 pp_string (pp
, ", ");
2274 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2275 pp_string (pp
, ", ");
2276 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2281 case BIT_INSERT_EXPR
:
2282 pp_string (pp
, "BIT_INSERT_EXPR <");
2283 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2284 pp_string (pp
, ", ");
2285 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2286 pp_string (pp
, ", ");
2287 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2288 pp_string (pp
, " (");
2289 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
2291 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
2293 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
2295 pp_string (pp
, " bits)>");
2299 case ARRAY_RANGE_REF
:
2300 op0
= TREE_OPERAND (node
, 0);
2301 if (op_prio (op0
) < op_prio (node
))
2303 dump_generic_node (pp
, op0
, spc
, flags
, false);
2304 if (op_prio (op0
) < op_prio (node
))
2305 pp_right_paren (pp
);
2306 pp_left_bracket (pp
);
2307 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2308 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
2309 pp_string (pp
, " ...");
2310 pp_right_bracket (pp
);
2312 op0
= array_ref_low_bound (node
);
2313 op1
= array_ref_element_size (node
);
2315 if (!integer_zerop (op0
)
2316 || TREE_OPERAND (node
, 2)
2317 || TREE_OPERAND (node
, 3))
2319 pp_string (pp
, "{lb: ");
2320 dump_generic_node (pp
, op0
, spc
, flags
, false);
2321 pp_string (pp
, " sz: ");
2322 dump_generic_node (pp
, op1
, spc
, flags
, false);
2323 pp_right_brace (pp
);
2329 unsigned HOST_WIDE_INT ix
;
2331 bool is_struct_init
= false;
2332 bool is_array_init
= false;
2334 if (flags
& TDF_GIMPLE
)
2336 pp_string (pp
, "_Literal (");
2337 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2338 pp_string (pp
, ") ");
2341 if (TREE_CLOBBER_P (node
))
2342 pp_string (pp
, "CLOBBER");
2343 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
2344 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
2345 is_struct_init
= true;
2346 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
2347 && TYPE_DOMAIN (TREE_TYPE (node
))
2348 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
2349 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
2352 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
2353 is_array_init
= true;
2354 curidx
= wi::to_widest (minv
);
2356 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
2363 dump_generic_node (pp
, field
, spc
, flags
, false);
2366 else if (is_array_init
2367 && (TREE_CODE (field
) != INTEGER_CST
2368 || curidx
!= wi::to_widest (field
)))
2370 pp_left_bracket (pp
);
2371 if (TREE_CODE (field
) == RANGE_EXPR
)
2373 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
2375 pp_string (pp
, " ... ");
2376 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
2378 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
2379 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
2382 dump_generic_node (pp
, field
, spc
, flags
, false);
2383 if (TREE_CODE (field
) == INTEGER_CST
)
2384 curidx
= wi::to_widest (field
);
2385 pp_string (pp
, "]=");
2390 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
2391 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
2392 val
= TREE_OPERAND (val
, 0);
2393 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
2394 dump_decl_name (pp
, val
, flags
);
2396 dump_generic_node (pp
, val
, spc
, flags
, false);
2397 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2403 pp_right_brace (pp
);
2410 if (flags
& TDF_SLIM
)
2412 pp_string (pp
, "<COMPOUND_EXPR>");
2416 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2417 spc
, flags
, !(flags
& TDF_SLIM
));
2418 if (flags
& TDF_SLIM
)
2419 newline_and_indent (pp
, spc
);
2426 for (tp
= &TREE_OPERAND (node
, 1);
2427 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2428 tp
= &TREE_OPERAND (*tp
, 1))
2430 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2431 spc
, flags
, !(flags
& TDF_SLIM
));
2432 if (flags
& TDF_SLIM
)
2433 newline_and_indent (pp
, spc
);
2441 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2445 case STATEMENT_LIST
:
2447 tree_stmt_iterator si
;
2450 if (flags
& TDF_SLIM
)
2452 pp_string (pp
, "<STATEMENT_LIST>");
2456 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2459 newline_and_indent (pp
, spc
);
2462 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2469 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2474 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2479 pp_string (pp
, "TARGET_EXPR <");
2480 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2483 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2488 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2493 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2495 pp_string (pp
, "if (");
2496 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2497 pp_right_paren (pp
);
2498 /* The lowered cond_exprs should always be printed in full. */
2499 if (COND_EXPR_THEN (node
)
2500 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2501 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2502 && COND_EXPR_ELSE (node
)
2503 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2504 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2507 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2509 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2511 pp_string (pp
, " else ");
2512 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2516 else if (!(flags
& TDF_SLIM
))
2518 /* Output COND_EXPR_THEN. */
2519 if (COND_EXPR_THEN (node
))
2521 newline_and_indent (pp
, spc
+2);
2523 newline_and_indent (pp
, spc
+4);
2524 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2526 newline_and_indent (pp
, spc
+2);
2527 pp_right_brace (pp
);
2530 /* Output COND_EXPR_ELSE. */
2531 if (COND_EXPR_ELSE (node
)
2532 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2534 newline_and_indent (pp
, spc
);
2535 pp_string (pp
, "else");
2536 newline_and_indent (pp
, spc
+2);
2538 newline_and_indent (pp
, spc
+4);
2539 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2541 newline_and_indent (pp
, spc
+2);
2542 pp_right_brace (pp
);
2549 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2553 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2557 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2563 if (!(flags
& TDF_SLIM
))
2565 if (BIND_EXPR_VARS (node
))
2569 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2571 print_declaration (pp
, op0
, spc
+2, flags
);
2576 newline_and_indent (pp
, spc
+2);
2577 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2578 newline_and_indent (pp
, spc
);
2579 pp_right_brace (pp
);
2585 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2586 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2590 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2593 /* Print parameters. */
2598 call_expr_arg_iterator iter
;
2599 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2601 dump_generic_node (pp
, arg
, spc
, flags
, false);
2602 if (more_call_expr_args_p (&iter
))
2609 if (CALL_EXPR_VA_ARG_PACK (node
))
2611 if (call_expr_nargs (node
) > 0)
2616 pp_string (pp
, "__builtin_va_arg_pack ()");
2618 pp_right_paren (pp
);
2620 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2623 pp_string (pp
, " [static-chain: ");
2624 dump_generic_node (pp
, op1
, spc
, flags
, false);
2625 pp_right_bracket (pp
);
2628 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2629 pp_string (pp
, " [return slot optimization]");
2630 if (CALL_EXPR_TAILCALL (node
))
2631 pp_string (pp
, " [tail call]");
2634 case WITH_CLEANUP_EXPR
:
2638 case CLEANUP_POINT_EXPR
:
2639 pp_string (pp
, "<<cleanup_point ");
2640 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2641 pp_string (pp
, ">>");
2644 case PLACEHOLDER_EXPR
:
2645 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2646 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2650 /* Binary arithmetic and logic expressions. */
2651 case WIDEN_SUM_EXPR
:
2652 case WIDEN_MULT_EXPR
:
2654 case MULT_HIGHPART_EXPR
:
2656 case POINTER_PLUS_EXPR
:
2657 case POINTER_DIFF_EXPR
:
2659 case TRUNC_DIV_EXPR
:
2661 case FLOOR_DIV_EXPR
:
2662 case ROUND_DIV_EXPR
:
2663 case TRUNC_MOD_EXPR
:
2665 case FLOOR_MOD_EXPR
:
2666 case ROUND_MOD_EXPR
:
2668 case EXACT_DIV_EXPR
:
2673 case WIDEN_LSHIFT_EXPR
:
2677 case TRUTH_ANDIF_EXPR
:
2678 case TRUTH_ORIF_EXPR
:
2679 case TRUTH_AND_EXPR
:
2681 case TRUTH_XOR_EXPR
:
2695 case UNORDERED_EXPR
:
2697 const char *op
= op_symbol (node
);
2698 op0
= TREE_OPERAND (node
, 0);
2699 op1
= TREE_OPERAND (node
, 1);
2701 /* When the operands are expressions with less priority,
2702 keep semantics of the tree representation. */
2703 if (op_prio (op0
) <= op_prio (node
))
2706 dump_generic_node (pp
, op0
, spc
, flags
, false);
2707 pp_right_paren (pp
);
2710 dump_generic_node (pp
, op0
, spc
, flags
, false);
2716 /* When the operands are expressions with less priority,
2717 keep semantics of the tree representation. */
2718 if (op_prio (op1
) <= op_prio (node
))
2721 dump_generic_node (pp
, op1
, spc
, flags
, false);
2722 pp_right_paren (pp
);
2725 dump_generic_node (pp
, op1
, spc
, flags
, false);
2729 /* Unary arithmetic and logic expressions. */
2732 case TRUTH_NOT_EXPR
:
2734 case PREDECREMENT_EXPR
:
2735 case PREINCREMENT_EXPR
:
2737 if (TREE_CODE (node
) == ADDR_EXPR
2738 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2739 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2740 ; /* Do not output '&' for strings and function pointers. */
2742 pp_string (pp
, op_symbol (node
));
2744 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2747 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2748 pp_right_paren (pp
);
2751 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2754 case POSTDECREMENT_EXPR
:
2755 case POSTINCREMENT_EXPR
:
2756 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2759 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2760 pp_right_paren (pp
);
2763 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2764 pp_string (pp
, op_symbol (node
));
2768 pp_string (pp
, "MIN_EXPR <");
2769 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2770 pp_string (pp
, ", ");
2771 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2776 pp_string (pp
, "MAX_EXPR <");
2777 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2778 pp_string (pp
, ", ");
2779 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2784 pp_string (pp
, "ABS_EXPR <");
2785 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2790 pp_string (pp
, "ABSU_EXPR <");
2791 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2799 case ADDR_SPACE_CONVERT_EXPR
:
2800 case FIXED_CONVERT_EXPR
:
2801 case FIX_TRUNC_EXPR
:
2804 type
= TREE_TYPE (node
);
2805 op0
= TREE_OPERAND (node
, 0);
2806 if (type
!= TREE_TYPE (op0
))
2809 dump_generic_node (pp
, type
, spc
, flags
, false);
2810 pp_string (pp
, ") ");
2812 if (op_prio (op0
) < op_prio (node
))
2814 dump_generic_node (pp
, op0
, spc
, flags
, false);
2815 if (op_prio (op0
) < op_prio (node
))
2816 pp_right_paren (pp
);
2819 case VIEW_CONVERT_EXPR
:
2820 if (flags
& TDF_GIMPLE
)
2821 pp_string (pp
, "__VIEW_CONVERT <");
2823 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2824 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2825 pp_string (pp
, ">(");
2826 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2827 pp_right_paren (pp
);
2831 pp_string (pp
, "((");
2832 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2833 pp_string (pp
, "))");
2836 case NON_LVALUE_EXPR
:
2837 pp_string (pp
, "NON_LVALUE_EXPR <");
2838 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2843 pp_string (pp
, "SAVE_EXPR <");
2844 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2849 pp_string (pp
, "COMPLEX_EXPR <");
2850 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2851 pp_string (pp
, ", ");
2852 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2857 pp_string (pp
, "CONJ_EXPR <");
2858 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2863 if (flags
& TDF_GIMPLE
)
2865 pp_string (pp
, "__real ");
2866 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2870 pp_string (pp
, "REALPART_EXPR <");
2871 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2877 if (flags
& TDF_GIMPLE
)
2879 pp_string (pp
, "__imag ");
2880 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2884 pp_string (pp
, "IMAGPART_EXPR <");
2885 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2891 pp_string (pp
, "VA_ARG_EXPR <");
2892 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2896 case TRY_FINALLY_EXPR
:
2897 case TRY_CATCH_EXPR
:
2898 pp_string (pp
, "try");
2899 newline_and_indent (pp
, spc
+2);
2901 newline_and_indent (pp
, spc
+4);
2902 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2903 newline_and_indent (pp
, spc
+2);
2904 pp_right_brace (pp
);
2905 newline_and_indent (pp
, spc
);
2906 if (TREE_CODE (node
) == TRY_CATCH_EXPR
)
2908 node
= TREE_OPERAND (node
, 1);
2909 pp_string (pp
, "catch");
2913 gcc_assert (TREE_CODE (node
) == TRY_FINALLY_EXPR
);
2914 node
= TREE_OPERAND (node
, 1);
2915 pp_string (pp
, "finally");
2916 if (TREE_CODE (node
) == EH_ELSE_EXPR
)
2918 newline_and_indent (pp
, spc
+2);
2920 newline_and_indent (pp
, spc
+4);
2921 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4,
2923 newline_and_indent (pp
, spc
+2);
2924 pp_right_brace (pp
);
2925 newline_and_indent (pp
, spc
);
2926 node
= TREE_OPERAND (node
, 1);
2927 pp_string (pp
, "else");
2930 newline_and_indent (pp
, spc
+2);
2932 newline_and_indent (pp
, spc
+4);
2933 dump_generic_node (pp
, node
, spc
+4, flags
, true);
2934 newline_and_indent (pp
, spc
+2);
2935 pp_right_brace (pp
);
2940 pp_string (pp
, "catch (");
2941 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2942 pp_right_paren (pp
);
2943 newline_and_indent (pp
, spc
+2);
2945 newline_and_indent (pp
, spc
+4);
2946 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2947 newline_and_indent (pp
, spc
+2);
2948 pp_right_brace (pp
);
2952 case EH_FILTER_EXPR
:
2953 pp_string (pp
, "<<<eh_filter (");
2954 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2955 pp_string (pp
, ")>>>");
2956 newline_and_indent (pp
, spc
+2);
2958 newline_and_indent (pp
, spc
+4);
2959 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2960 newline_and_indent (pp
, spc
+2);
2961 pp_right_brace (pp
);
2966 op0
= TREE_OPERAND (node
, 0);
2967 /* If this is for break or continue, don't bother printing it. */
2968 if (DECL_NAME (op0
))
2970 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2971 if (strcmp (name
, "break") == 0
2972 || strcmp (name
, "continue") == 0)
2975 dump_generic_node (pp
, op0
, spc
, flags
, false);
2977 if (DECL_NONLOCAL (op0
))
2978 pp_string (pp
, " [non-local]");
2982 pp_string (pp
, "while (1)");
2983 if (!(flags
& TDF_SLIM
))
2985 newline_and_indent (pp
, spc
+2);
2987 newline_and_indent (pp
, spc
+4);
2988 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2989 newline_and_indent (pp
, spc
+2);
2990 pp_right_brace (pp
);
2996 pp_string (pp
, "// predicted ");
2997 if (PREDICT_EXPR_OUTCOME (node
))
2998 pp_string (pp
, "likely by ");
3000 pp_string (pp
, "unlikely by ");
3001 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
3002 pp_string (pp
, " predictor.");
3006 pp_string (pp
, "ANNOTATE_EXPR <");
3007 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3008 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
3010 case annot_expr_ivdep_kind
:
3011 pp_string (pp
, ", ivdep");
3013 case annot_expr_unroll_kind
:
3014 pp_printf (pp
, ", unroll %d",
3015 (int) TREE_INT_CST_LOW (TREE_OPERAND (node
, 2)));
3017 case annot_expr_no_vector_kind
:
3018 pp_string (pp
, ", no-vector");
3020 case annot_expr_vector_kind
:
3021 pp_string (pp
, ", vector");
3023 case annot_expr_parallel_kind
:
3024 pp_string (pp
, ", parallel");
3033 pp_string (pp
, "return");
3034 op0
= TREE_OPERAND (node
, 0);
3038 if (TREE_CODE (op0
) == MODIFY_EXPR
)
3039 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
3042 dump_generic_node (pp
, op0
, spc
, flags
, false);
3047 pp_string (pp
, "if (");
3048 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3049 pp_string (pp
, ") break");
3053 pp_string (pp
, "switch (");
3054 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
3055 pp_right_paren (pp
);
3056 if (!(flags
& TDF_SLIM
))
3058 newline_and_indent (pp
, spc
+2);
3060 if (SWITCH_BODY (node
))
3062 newline_and_indent (pp
, spc
+4);
3063 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
3066 newline_and_indent (pp
, spc
+2);
3067 pp_right_brace (pp
);
3073 op0
= GOTO_DESTINATION (node
);
3074 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
3076 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
3077 if (strcmp (name
, "break") == 0
3078 || strcmp (name
, "continue") == 0)
3080 pp_string (pp
, name
);
3084 pp_string (pp
, "goto ");
3085 dump_generic_node (pp
, op0
, spc
, flags
, false);
3089 pp_string (pp
, "__asm__");
3090 if (ASM_VOLATILE_P (node
))
3091 pp_string (pp
, " __volatile__");
3093 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
3095 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
3097 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
3098 if (ASM_CLOBBERS (node
))
3101 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
3103 pp_right_paren (pp
);
3106 case CASE_LABEL_EXPR
:
3107 if (CASE_LOW (node
) && CASE_HIGH (node
))
3109 pp_string (pp
, "case ");
3110 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
3111 pp_string (pp
, " ... ");
3112 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
3114 else if (CASE_LOW (node
))
3116 pp_string (pp
, "case ");
3117 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
3120 pp_string (pp
, "default");
3125 pp_string (pp
, "OBJ_TYPE_REF(");
3126 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
3128 /* We omit the class type for -fcompare-debug because we may
3129 drop TYPE_BINFO early depending on debug info, and then
3130 virtual_method_call_p would return false, whereas when
3131 TYPE_BINFO is preserved it may still return true and then
3132 we'd print the class type. Compare tree and rtl dumps for
3133 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
3134 for example, at occurrences of OBJ_TYPE_REF. */
3135 if (!(flags
& (TDF_SLIM
| TDF_COMPARE_DEBUG
))
3136 && virtual_method_call_p (node
, true))
3138 pp_string (pp
, "(");
3139 dump_generic_node (pp
, obj_type_ref_class (node
, true),
3141 pp_string (pp
, ")");
3143 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
3145 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
3146 pp_right_paren (pp
);
3150 if (SSA_NAME_IDENTIFIER (node
))
3152 if ((flags
& TDF_NOUID
)
3153 && SSA_NAME_VAR (node
)
3154 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
3155 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
3156 else if (! (flags
& TDF_GIMPLE
)
3157 || SSA_NAME_VAR (node
))
3158 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
3162 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
3163 if (SSA_NAME_IS_DEFAULT_DEF (node
))
3164 pp_string (pp
, "(D)");
3165 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
3166 pp_string (pp
, "(ab)");
3169 case WITH_SIZE_EXPR
:
3170 pp_string (pp
, "WITH_SIZE_EXPR <");
3171 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3172 pp_string (pp
, ", ");
3173 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3178 pp_string (pp
, "ASSERT_EXPR <");
3179 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
3180 pp_string (pp
, ", ");
3181 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
3186 pp_string (pp
, "scev_known");
3189 case SCEV_NOT_KNOWN
:
3190 pp_string (pp
, "scev_not_known");
3193 case POLYNOMIAL_CHREC
:
3195 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
3196 pp_string (pp
, ", +, ");
3197 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
3198 pp_printf (pp
, "}_%u", CHREC_VARIABLE (node
));
3202 case REALIGN_LOAD_EXPR
:
3203 pp_string (pp
, "REALIGN_LOAD <");
3204 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3205 pp_string (pp
, ", ");
3206 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3207 pp_string (pp
, ", ");
3208 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3213 pp_string (pp
, " VEC_COND_EXPR < ");
3214 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3215 pp_string (pp
, " , ");
3216 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3217 pp_string (pp
, " , ");
3218 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3219 pp_string (pp
, " > ");
3223 pp_string (pp
, " VEC_PERM_EXPR < ");
3224 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3225 pp_string (pp
, " , ");
3226 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3227 pp_string (pp
, " , ");
3228 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3229 pp_string (pp
, " > ");
3233 pp_string (pp
, " DOT_PROD_EXPR < ");
3234 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3235 pp_string (pp
, ", ");
3236 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3237 pp_string (pp
, ", ");
3238 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3239 pp_string (pp
, " > ");
3242 case WIDEN_MULT_PLUS_EXPR
:
3243 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
3244 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3245 pp_string (pp
, ", ");
3246 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3247 pp_string (pp
, ", ");
3248 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3249 pp_string (pp
, " > ");
3252 case WIDEN_MULT_MINUS_EXPR
:
3253 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
3254 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3255 pp_string (pp
, ", ");
3256 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3257 pp_string (pp
, ", ");
3258 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3259 pp_string (pp
, " > ");
3263 pp_string (pp
, "#pragma acc parallel");
3264 goto dump_omp_clauses_body
;
3267 pp_string (pp
, "#pragma acc kernels");
3268 goto dump_omp_clauses_body
;
3271 pp_string (pp
, "#pragma acc serial");
3272 goto dump_omp_clauses_body
;
3275 pp_string (pp
, "#pragma acc data");
3276 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
3279 case OACC_HOST_DATA
:
3280 pp_string (pp
, "#pragma acc host_data");
3281 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
3285 pp_string (pp
, "#pragma acc declare");
3286 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
3290 pp_string (pp
, "#pragma acc update");
3291 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
3294 case OACC_ENTER_DATA
:
3295 pp_string (pp
, "#pragma acc enter data");
3296 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3299 case OACC_EXIT_DATA
:
3300 pp_string (pp
, "#pragma acc exit data");
3301 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3305 pp_string (pp
, "#pragma acc cache");
3306 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
3310 pp_string (pp
, "#pragma omp parallel");
3311 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
3314 dump_omp_clauses_body
:
3315 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
3319 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
3321 newline_and_indent (pp
, spc
+ 2);
3323 newline_and_indent (pp
, spc
+ 4);
3324 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
3325 newline_and_indent (pp
, spc
+ 2);
3326 pp_right_brace (pp
);
3332 pp_string (pp
, OMP_TASK_BODY (node
) ? "#pragma omp task"
3333 : "#pragma omp taskwait");
3334 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
3338 pp_string (pp
, "#pragma omp for");
3342 pp_string (pp
, "#pragma omp simd");
3345 case OMP_DISTRIBUTE
:
3346 pp_string (pp
, "#pragma omp distribute");
3350 pp_string (pp
, "#pragma omp taskloop");
3354 pp_string (pp
, "#pragma omp loop");
3358 pp_string (pp
, "#pragma acc loop");
3362 pp_string (pp
, "#pragma omp teams");
3363 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
3366 case OMP_TARGET_DATA
:
3367 pp_string (pp
, "#pragma omp target data");
3368 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
3371 case OMP_TARGET_ENTER_DATA
:
3372 pp_string (pp
, "#pragma omp target enter data");
3373 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3377 case OMP_TARGET_EXIT_DATA
:
3378 pp_string (pp
, "#pragma omp target exit data");
3379 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3384 pp_string (pp
, "#pragma omp target");
3385 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3388 case OMP_TARGET_UPDATE
:
3389 pp_string (pp
, "#pragma omp target update");
3390 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3395 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3396 if (!(flags
& TDF_SLIM
))
3400 if (OMP_FOR_PRE_BODY (node
))
3402 newline_and_indent (pp
, spc
+ 2);
3405 newline_and_indent (pp
, spc
);
3406 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3409 if (OMP_FOR_INIT (node
))
3412 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3415 newline_and_indent (pp
, spc
);
3416 pp_string (pp
, "for (");
3417 tree init
= TREE_VEC_ELT (OMP_FOR_INIT (node
), i
);
3418 if (TREE_CODE (init
) != MODIFY_EXPR
3419 || TREE_CODE (TREE_OPERAND (init
, 1)) != TREE_VEC
)
3420 dump_generic_node (pp
, init
, spc
, flags
, false);
3423 dump_generic_node (pp
, TREE_OPERAND (init
, 0),
3425 pp_string (pp
, " = ");
3426 dump_omp_loop_non_rect_expr (pp
, TREE_OPERAND (init
, 1),
3429 pp_string (pp
, "; ");
3430 tree cond
= TREE_VEC_ELT (OMP_FOR_COND (node
), i
);
3431 if (!COMPARISON_CLASS_P (cond
)
3432 || TREE_CODE (TREE_OPERAND (cond
, 1)) != TREE_VEC
)
3433 dump_generic_node (pp
, cond
, spc
, flags
, false);
3436 dump_generic_node (pp
, TREE_OPERAND (cond
, 0),
3438 const char *op
= op_symbol (cond
);
3442 dump_omp_loop_non_rect_expr (pp
, TREE_OPERAND (cond
, 1),
3445 pp_string (pp
, "; ");
3446 dump_generic_node (pp
,
3447 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3449 pp_right_paren (pp
);
3452 if (OMP_FOR_BODY (node
))
3454 newline_and_indent (pp
, spc
+ 2);
3456 newline_and_indent (pp
, spc
+ 4);
3457 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3459 newline_and_indent (pp
, spc
+ 2);
3460 pp_right_brace (pp
);
3462 if (OMP_FOR_INIT (node
))
3463 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3464 if (OMP_FOR_PRE_BODY (node
))
3467 newline_and_indent (pp
, spc
+ 2);
3468 pp_right_brace (pp
);
3475 pp_string (pp
, "#pragma omp sections");
3476 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3480 pp_string (pp
, "#pragma omp section");
3484 if (OMP_SCAN_CLAUSES (node
))
3486 pp_string (pp
, "#pragma omp scan");
3487 dump_omp_clauses (pp
, OMP_SCAN_CLAUSES (node
), spc
, flags
);
3492 pp_string (pp
, "#pragma omp master");
3496 pp_string (pp
, "#pragma omp taskgroup");
3497 dump_omp_clauses (pp
, OMP_TASKGROUP_CLAUSES (node
), spc
, flags
);
3501 pp_string (pp
, "#pragma omp ordered");
3502 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3506 pp_string (pp
, "#pragma omp critical");
3507 if (OMP_CRITICAL_NAME (node
))
3511 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3513 pp_right_paren (pp
);
3515 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3519 pp_string (pp
, "#pragma omp atomic");
3520 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3521 newline_and_indent (pp
, spc
+ 2);
3522 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3526 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3529 case OMP_ATOMIC_READ
:
3530 pp_string (pp
, "#pragma omp atomic read");
3531 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3532 newline_and_indent (pp
, spc
+ 2);
3533 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3537 case OMP_ATOMIC_CAPTURE_OLD
:
3538 case OMP_ATOMIC_CAPTURE_NEW
:
3539 pp_string (pp
, "#pragma omp atomic capture");
3540 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3541 newline_and_indent (pp
, spc
+ 2);
3542 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3546 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3550 pp_string (pp
, "#pragma omp single");
3551 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3555 dump_omp_clause (pp
, node
, spc
, flags
);
3559 case TRANSACTION_EXPR
:
3560 if (TRANSACTION_EXPR_OUTER (node
))
3561 pp_string (pp
, "__transaction_atomic [[outer]]");
3562 else if (TRANSACTION_EXPR_RELAXED (node
))
3563 pp_string (pp
, "__transaction_relaxed");
3565 pp_string (pp
, "__transaction_atomic");
3566 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3568 newline_and_indent (pp
, spc
);
3570 newline_and_indent (pp
, spc
+ 2);
3571 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3572 spc
+ 2, flags
, false);
3573 newline_and_indent (pp
, spc
);
3574 pp_right_brace (pp
);
3579 case VEC_SERIES_EXPR
:
3580 case VEC_WIDEN_MULT_HI_EXPR
:
3581 case VEC_WIDEN_MULT_LO_EXPR
:
3582 case VEC_WIDEN_MULT_EVEN_EXPR
:
3583 case VEC_WIDEN_MULT_ODD_EXPR
:
3584 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3585 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3587 for (str
= get_tree_code_name (code
); *str
; str
++)
3588 pp_character (pp
, TOUPPER (*str
));
3589 pp_string (pp
, " < ");
3590 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3591 pp_string (pp
, ", ");
3592 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3593 pp_string (pp
, " > ");
3596 case VEC_DUPLICATE_EXPR
:
3598 for (str
= get_tree_code_name (code
); *str
; str
++)
3599 pp_character (pp
, TOUPPER (*str
));
3600 pp_string (pp
, " < ");
3601 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3602 pp_string (pp
, " > ");
3605 case VEC_UNPACK_HI_EXPR
:
3606 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3607 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3608 pp_string (pp
, " > ");
3611 case VEC_UNPACK_LO_EXPR
:
3612 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3613 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3614 pp_string (pp
, " > ");
3617 case VEC_UNPACK_FLOAT_HI_EXPR
:
3618 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3619 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3620 pp_string (pp
, " > ");
3623 case VEC_UNPACK_FLOAT_LO_EXPR
:
3624 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3625 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3626 pp_string (pp
, " > ");
3629 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3630 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
3631 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3632 pp_string (pp
, " > ");
3635 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3636 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
3637 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3638 pp_string (pp
, " > ");
3641 case VEC_PACK_TRUNC_EXPR
:
3642 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3643 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3644 pp_string (pp
, ", ");
3645 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3646 pp_string (pp
, " > ");
3649 case VEC_PACK_SAT_EXPR
:
3650 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3651 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3652 pp_string (pp
, ", ");
3653 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3654 pp_string (pp
, " > ");
3657 case VEC_PACK_FIX_TRUNC_EXPR
:
3658 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3659 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3660 pp_string (pp
, ", ");
3661 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3662 pp_string (pp
, " > ");
3665 case VEC_PACK_FLOAT_EXPR
:
3666 pp_string (pp
, " VEC_PACK_FLOAT_EXPR < ");
3667 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3668 pp_string (pp
, ", ");
3669 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3670 pp_string (pp
, " > ");
3674 dump_block_node (pp
, node
, spc
, flags
);
3677 case DEBUG_BEGIN_STMT
:
3678 pp_string (pp
, "# DEBUG BEGIN STMT");
3685 if (is_stmt
&& is_expr
)
3691 /* Print the declaration of a variable. */
3694 print_declaration (pretty_printer
*pp
, tree t
, int spc
, dump_flags_t flags
)
3698 if (TREE_CODE(t
) == NAMELIST_DECL
)
3700 pp_string(pp
, "namelist ");
3701 dump_decl_name (pp
, t
, flags
);
3706 if (TREE_CODE (t
) == TYPE_DECL
)
3707 pp_string (pp
, "typedef ");
3709 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3710 pp_string (pp
, "register ");
3712 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3713 pp_string (pp
, "extern ");
3714 else if (TREE_STATIC (t
))
3715 pp_string (pp
, "static ");
3717 /* Print the type and name. */
3718 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3722 /* Print array's type. */
3723 tmp
= TREE_TYPE (t
);
3724 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3725 tmp
= TREE_TYPE (tmp
);
3726 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3728 /* Print variable's name. */
3730 dump_generic_node (pp
, t
, spc
, flags
, false);
3732 /* Print the dimensions. */
3733 tmp
= TREE_TYPE (t
);
3734 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3736 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3737 tmp
= TREE_TYPE (tmp
);
3740 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3742 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3744 dump_decl_name (pp
, t
, flags
);
3745 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3749 /* Print type declaration. */
3750 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3752 /* Print variable's name. */
3754 dump_generic_node (pp
, t
, spc
, flags
, false);
3757 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
3759 pp_string (pp
, " __asm__ ");
3761 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3762 pp_right_paren (pp
);
3765 /* The initial value of a function serves to determine whether the function
3766 is declared or defined. So the following does not apply to function
3768 if (TREE_CODE (t
) != FUNCTION_DECL
)
3770 /* Print the initial value. */
3771 if (DECL_INITIAL (t
))
3776 if (!(flags
& TDF_SLIM
))
3777 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3779 pp_string (pp
, "<<< omitted >>>");
3783 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3785 pp_string (pp
, " [value-expr: ");
3786 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3787 pp_right_bracket (pp
);
3794 /* Prints a structure: name, fields, and methods.
3795 FIXME: Still incomplete. */
3798 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
3801 /* Print the name of the structure. */
3802 if (TYPE_NAME (node
))
3805 if (TREE_CODE (node
) == RECORD_TYPE
)
3806 pp_string (pp
, "struct ");
3807 else if ((TREE_CODE (node
) == UNION_TYPE
3808 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3809 pp_string (pp
, "union ");
3811 dump_generic_node (pp
, TYPE_NAME (node
), spc
, TDF_NONE
, false);
3814 /* Print the contents of the structure. */
3820 /* Print the fields of the structure. */
3823 tmp
= TYPE_FIELDS (node
);
3826 /* Avoid to print recursively the structure. */
3827 /* FIXME : Not implemented correctly...,
3828 what about the case when we have a cycle in the contain graph? ...
3829 Maybe this could be solved by looking at the scope in which the
3830 structure was declared. */
3831 if (TREE_TYPE (tmp
) != node
3832 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3833 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3835 print_declaration (pp
, tmp
, spc
+2, flags
);
3838 tmp
= DECL_CHAIN (tmp
);
3842 pp_right_brace (pp
);
3845 /* Return the priority of the operator CODE.
3847 From lowest to highest precedence with either left-to-right (L-R)
3848 or right-to-left (R-L) associativity]:
3851 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3863 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3864 15 [L-R] fn() [] -> .
3866 unary +, - and * have higher precedence than the corresponding binary
3870 op_code_prio (enum tree_code code
)
3887 case TRUTH_ORIF_EXPR
:
3890 case TRUTH_AND_EXPR
:
3891 case TRUTH_ANDIF_EXPR
:
3898 case TRUTH_XOR_EXPR
:
3915 case UNORDERED_EXPR
:
3926 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3927 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3928 case WIDEN_LSHIFT_EXPR
:
3931 case WIDEN_SUM_EXPR
:
3933 case POINTER_PLUS_EXPR
:
3934 case POINTER_DIFF_EXPR
:
3938 case VEC_WIDEN_MULT_HI_EXPR
:
3939 case VEC_WIDEN_MULT_LO_EXPR
:
3940 case WIDEN_MULT_EXPR
:
3942 case WIDEN_MULT_PLUS_EXPR
:
3943 case WIDEN_MULT_MINUS_EXPR
:
3945 case MULT_HIGHPART_EXPR
:
3946 case TRUNC_DIV_EXPR
:
3948 case FLOOR_DIV_EXPR
:
3949 case ROUND_DIV_EXPR
:
3951 case EXACT_DIV_EXPR
:
3952 case TRUNC_MOD_EXPR
:
3954 case FLOOR_MOD_EXPR
:
3955 case ROUND_MOD_EXPR
:
3958 case TRUTH_NOT_EXPR
:
3960 case POSTINCREMENT_EXPR
:
3961 case POSTDECREMENT_EXPR
:
3962 case PREINCREMENT_EXPR
:
3963 case PREDECREMENT_EXPR
:
3969 case FIX_TRUNC_EXPR
:
3975 case ARRAY_RANGE_REF
:
3979 /* Special expressions. */
3985 case VEC_UNPACK_HI_EXPR
:
3986 case VEC_UNPACK_LO_EXPR
:
3987 case VEC_UNPACK_FLOAT_HI_EXPR
:
3988 case VEC_UNPACK_FLOAT_LO_EXPR
:
3989 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3990 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3991 case VEC_PACK_TRUNC_EXPR
:
3992 case VEC_PACK_SAT_EXPR
:
3996 /* Return an arbitrarily high precedence to avoid surrounding single
3997 VAR_DECLs in ()s. */
4002 /* Return the priority of the operator OP. */
4005 op_prio (const_tree op
)
4007 enum tree_code code
;
4012 code
= TREE_CODE (op
);
4013 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
4014 return op_prio (TREE_OPERAND (op
, 0));
4016 return op_code_prio (code
);
4019 /* Return the symbol associated with operator CODE. */
4022 op_symbol_code (enum tree_code code
)
4030 case TRUTH_ORIF_EXPR
:
4033 case TRUTH_AND_EXPR
:
4034 case TRUTH_ANDIF_EXPR
:
4040 case TRUTH_XOR_EXPR
:
4050 case UNORDERED_EXPR
:
4096 case WIDEN_LSHIFT_EXPR
:
4099 case POINTER_PLUS_EXPR
:
4105 case WIDEN_SUM_EXPR
:
4108 case WIDEN_MULT_EXPR
:
4111 case MULT_HIGHPART_EXPR
:
4116 case POINTER_DIFF_EXPR
:
4122 case TRUTH_NOT_EXPR
:
4129 case TRUNC_DIV_EXPR
:
4136 case FLOOR_DIV_EXPR
:
4139 case ROUND_DIV_EXPR
:
4142 case EXACT_DIV_EXPR
:
4145 case TRUNC_MOD_EXPR
:
4151 case FLOOR_MOD_EXPR
:
4154 case ROUND_MOD_EXPR
:
4157 case PREDECREMENT_EXPR
:
4160 case PREINCREMENT_EXPR
:
4163 case POSTDECREMENT_EXPR
:
4166 case POSTINCREMENT_EXPR
:
4176 return "<<< ??? >>>";
4180 /* Return the symbol associated with operator OP. */
4183 op_symbol (const_tree op
)
4185 return op_symbol_code (TREE_CODE (op
));
4188 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
4189 the gimple_call_fn of a GIMPLE_CALL. */
4192 print_call_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
4196 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
4197 op0
= TREE_OPERAND (op0
, 0);
4200 switch (TREE_CODE (op0
))
4205 dump_function_name (pp
, op0
, flags
);
4211 op0
= TREE_OPERAND (op0
, 0);
4216 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
4217 pp_string (pp
, ") ? ");
4218 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
4219 pp_string (pp
, " : ");
4220 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
4224 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
4225 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
4227 dump_generic_node (pp
, op0
, 0, flags
, false);
4231 if (integer_zerop (TREE_OPERAND (op0
, 1)))
4233 op0
= TREE_OPERAND (op0
, 0);
4240 dump_generic_node (pp
, op0
, 0, flags
, false);
4248 /* Print the first N characters in the array STR, replacing non-printable
4249 characters (including embedded nuls) with unambiguous escape sequences. */
4252 pretty_print_string (pretty_printer
*pp
, const char *str
, size_t n
)
4257 for ( ; n
; --n
, ++str
)
4262 pp_string (pp
, "\\b");
4266 pp_string (pp
, "\\f");
4270 pp_string (pp
, "\\n");
4274 pp_string (pp
, "\\r");
4278 pp_string (pp
, "\\t");
4282 pp_string (pp
, "\\v");
4286 pp_string (pp
, "\\\\");
4290 pp_string (pp
, "\\\"");
4294 pp_string (pp
, "\\'");
4298 if (str
[0] || n
> 1)
4300 if (!ISPRINT (str
[0]))
4303 sprintf (buf
, "\\x%02x", (unsigned char)str
[0]);
4304 pp_string (pp
, buf
);
4307 pp_character (pp
, str
[0]);
4315 maybe_init_pretty_print (FILE *file
)
4319 tree_pp
= new pretty_printer ();
4320 pp_needs_newline (tree_pp
) = true;
4321 pp_translate_identifiers (tree_pp
) = false;
4324 tree_pp
->buffer
->stream
= file
;
4328 newline_and_indent (pretty_printer
*pp
, int spc
)
4334 /* Handle the %K format for TEXT. Separate from default_tree_printer
4335 so it can also be used in front ends.
4336 The location LOC and BLOCK are expected to be extracted by the caller
4337 from the %K argument arg via EXPR_LOCATION(arg) and TREE_BLOCK(arg). */
4340 percent_K_format (text_info
*text
, location_t loc
, tree block
)
4342 text
->set_location (0, loc
, SHOW_RANGE_WITH_CARET
);
4343 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
4344 *pp_ti_abstract_origin (text
) = NULL
;
4347 && TREE_CODE (block
) == BLOCK
4348 && BLOCK_ABSTRACT_ORIGIN (block
))
4350 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
4351 if (TREE_CODE (ao
) == FUNCTION_DECL
)
4353 *pp_ti_abstract_origin (text
) = block
;
4356 block
= BLOCK_SUPERCONTEXT (block
);
4360 /* Print the identifier ID to PRETTY-PRINTER. */
4363 pp_tree_identifier (pretty_printer
*pp
, tree id
)
4365 if (pp_translate_identifiers (pp
))
4367 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
4368 pp_append_text (pp
, text
, text
+ strlen (text
));
4371 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
4372 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
4375 /* A helper function that is used to dump function information before the
4379 dump_function_header (FILE *dump_file
, tree fdecl
, dump_flags_t flags
)
4381 const char *dname
, *aname
;
4382 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
4383 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
4385 dname
= lang_hooks
.decl_printable_name (fdecl
, 1);
4387 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
4388 aname
= (IDENTIFIER_POINTER
4389 (DECL_ASSEMBLER_NAME (fdecl
)));
4391 aname
= "<unset-asm-name>";
4393 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
4394 dname
, aname
, fun
->funcdef_no
);
4395 if (!(flags
& TDF_NOUID
))
4396 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
4399 fprintf (dump_file
, ", cgraph_uid=%d", node
->get_uid ());
4400 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
4401 node
->frequency
== NODE_FREQUENCY_HOT
4403 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
4404 ? " (unlikely executed)"
4405 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
4406 ? " (executed once)"
4410 fprintf (dump_file
, ")\n\n");
4413 /* Dump double_int D to pretty_printer PP. UNS is true
4414 if D is unsigned and false otherwise. */
4416 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4419 pp_wide_integer (pp
, d
.low
);
4420 else if (d
.fits_uhwi ())
4421 pp_unsigned_wide_integer (pp
, d
.low
);
4424 unsigned HOST_WIDE_INT low
= d
.low
;
4425 HOST_WIDE_INT high
= d
.high
;
4426 if (!uns
&& d
.is_negative ())
4429 high
= ~high
+ !low
;
4432 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4434 sprintf (pp_buffer (pp
)->digit_buffer
,
4435 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4436 (unsigned HOST_WIDE_INT
) high
, low
);
4437 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
4442 # pragma GCC diagnostic pop