1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2019 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
29 #include "tree-pretty-print.h"
30 #include "stor-layout.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
34 #include "internal-fn.h"
35 #include "gomp-constants.h"
38 /* Disable warnings about quoting issues in the pp_xxx calls below
39 that (intentionally) don't follow GCC diagnostic conventions. */
41 # pragma GCC diagnostic push
42 # pragma GCC diagnostic ignored "-Wformat-diag"
45 /* Local functions, macros and variables. */
46 static const char *op_symbol (const_tree
);
47 static void pretty_print_string (pretty_printer
*, const char*, unsigned);
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
)
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
))
450 pp_string (pp
, "lastprivate(conditional:");
451 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
455 case OMP_CLAUSE_COPYIN
:
458 case OMP_CLAUSE_COPYPRIVATE
:
459 name
= "copyprivate";
461 case OMP_CLAUSE_UNIFORM
:
464 case OMP_CLAUSE_USE_DEVICE_PTR
:
465 name
= "use_device_ptr";
467 case OMP_CLAUSE_IS_DEVICE_PTR
:
468 name
= "is_device_ptr";
470 case OMP_CLAUSE_INCLUSIVE
:
473 case OMP_CLAUSE_EXCLUSIVE
:
476 case OMP_CLAUSE__LOOPTEMP_
:
479 case OMP_CLAUSE__REDUCTEMP_
:
480 name
= "_reductemp_";
482 case OMP_CLAUSE__CONDTEMP_
:
485 case OMP_CLAUSE_TO_DECLARE
:
488 case OMP_CLAUSE_LINK
:
491 case OMP_CLAUSE_NONTEMPORAL
:
492 name
= "nontemporal";
495 pp_string (pp
, name
);
497 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
502 case OMP_CLAUSE_TASK_REDUCTION
:
503 case OMP_CLAUSE_IN_REDUCTION
:
504 pp_string (pp
, OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_IN_REDUCTION
507 case OMP_CLAUSE_REDUCTION
:
508 pp_string (pp
, "reduction(");
509 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_REDUCTION
)
511 if (OMP_CLAUSE_REDUCTION_TASK (clause
))
512 pp_string (pp
, "task,");
513 else if (OMP_CLAUSE_REDUCTION_INSCAN (clause
))
514 pp_string (pp
, "inscan,");
516 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
519 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
522 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
528 pp_string (pp
, "if(");
529 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
531 case ERROR_MARK
: break;
532 case VOID_CST
: pp_string (pp
, "cancel:"); break;
533 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
534 case OMP_SIMD
: pp_string (pp
, "simd:"); break;
535 case OMP_TASK
: pp_string (pp
, "task:"); break;
536 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
537 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
538 case OMP_TARGET
: pp_string (pp
, "target:"); break;
539 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
540 case OMP_TARGET_ENTER_DATA
:
541 pp_string (pp
, "target enter data:"); break;
542 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
543 default: gcc_unreachable ();
545 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
550 case OMP_CLAUSE_NUM_THREADS
:
551 pp_string (pp
, "num_threads(");
552 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
557 case OMP_CLAUSE_NOWAIT
:
558 pp_string (pp
, "nowait");
560 case OMP_CLAUSE_ORDERED
:
561 pp_string (pp
, "ordered");
562 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
565 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
571 case OMP_CLAUSE_DEFAULT
:
572 pp_string (pp
, "default(");
573 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
575 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
577 case OMP_CLAUSE_DEFAULT_SHARED
:
578 pp_string (pp
, "shared");
580 case OMP_CLAUSE_DEFAULT_NONE
:
581 pp_string (pp
, "none");
583 case OMP_CLAUSE_DEFAULT_PRIVATE
:
584 pp_string (pp
, "private");
586 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
587 pp_string (pp
, "firstprivate");
589 case OMP_CLAUSE_DEFAULT_PRESENT
:
590 pp_string (pp
, "present");
598 case OMP_CLAUSE_SCHEDULE
:
599 pp_string (pp
, "schedule(");
600 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
601 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
602 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
604 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
605 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
606 pp_string (pp
, "monotonic");
608 pp_string (pp
, "nonmonotonic");
609 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
614 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
615 pp_string (pp
, "simd:");
617 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
619 case OMP_CLAUSE_SCHEDULE_STATIC
:
620 pp_string (pp
, "static");
622 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
623 pp_string (pp
, "dynamic");
625 case OMP_CLAUSE_SCHEDULE_GUIDED
:
626 pp_string (pp
, "guided");
628 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
629 pp_string (pp
, "runtime");
631 case OMP_CLAUSE_SCHEDULE_AUTO
:
632 pp_string (pp
, "auto");
637 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
640 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
646 case OMP_CLAUSE_UNTIED
:
647 pp_string (pp
, "untied");
650 case OMP_CLAUSE_COLLAPSE
:
651 pp_string (pp
, "collapse(");
652 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
657 case OMP_CLAUSE_FINAL
:
658 pp_string (pp
, "final(");
659 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
664 case OMP_CLAUSE_MERGEABLE
:
665 pp_string (pp
, "mergeable");
668 case OMP_CLAUSE_LINEAR
:
669 pp_string (pp
, "linear(");
670 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
672 case OMP_CLAUSE_LINEAR_DEFAULT
:
674 case OMP_CLAUSE_LINEAR_REF
:
675 pp_string (pp
, "ref(");
677 case OMP_CLAUSE_LINEAR_VAL
:
678 pp_string (pp
, "val(");
680 case OMP_CLAUSE_LINEAR_UVAL
:
681 pp_string (pp
, "uval(");
686 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
688 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
691 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
696 case OMP_CLAUSE_ALIGNED
:
697 pp_string (pp
, "aligned(");
698 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
700 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
703 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
709 case OMP_CLAUSE_DEPEND
:
710 pp_string (pp
, "depend(");
711 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
713 case OMP_CLAUSE_DEPEND_DEPOBJ
:
716 case OMP_CLAUSE_DEPEND_IN
:
719 case OMP_CLAUSE_DEPEND_OUT
:
722 case OMP_CLAUSE_DEPEND_INOUT
:
725 case OMP_CLAUSE_DEPEND_MUTEXINOUTSET
:
726 name
= "mutexinoutset";
728 case OMP_CLAUSE_DEPEND_SOURCE
:
729 pp_string (pp
, "source)");
731 case OMP_CLAUSE_DEPEND_LAST
:
732 name
= "__internal__";
734 case OMP_CLAUSE_DEPEND_SINK
:
735 pp_string (pp
, "sink:");
736 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
737 if (TREE_CODE (t
) == TREE_LIST
)
739 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
740 if (TREE_PURPOSE (t
) != integer_zero_node
)
742 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
746 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
760 tree t
= OMP_CLAUSE_DECL (clause
);
761 if (TREE_CODE (t
) == TREE_LIST
763 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
765 dump_omp_iterators (pp
, TREE_PURPOSE (t
), spc
, flags
);
769 pp_string (pp
, name
);
771 dump_generic_node (pp
, t
, spc
, flags
, false);
777 pp_string (pp
, "map(");
778 switch (OMP_CLAUSE_MAP_KIND (clause
))
781 case GOMP_MAP_POINTER
:
782 pp_string (pp
, "alloc");
785 case GOMP_MAP_TO_PSET
:
786 pp_string (pp
, "to");
789 pp_string (pp
, "from");
791 case GOMP_MAP_TOFROM
:
792 pp_string (pp
, "tofrom");
794 case GOMP_MAP_FORCE_ALLOC
:
795 pp_string (pp
, "force_alloc");
797 case GOMP_MAP_FORCE_TO
:
798 pp_string (pp
, "force_to");
800 case GOMP_MAP_FORCE_FROM
:
801 pp_string (pp
, "force_from");
803 case GOMP_MAP_FORCE_TOFROM
:
804 pp_string (pp
, "force_tofrom");
806 case GOMP_MAP_FORCE_PRESENT
:
807 pp_string (pp
, "force_present");
809 case GOMP_MAP_DELETE
:
810 pp_string (pp
, "delete");
812 case GOMP_MAP_FORCE_DEVICEPTR
:
813 pp_string (pp
, "force_deviceptr");
815 case GOMP_MAP_ALWAYS_TO
:
816 pp_string (pp
, "always,to");
818 case GOMP_MAP_ALWAYS_FROM
:
819 pp_string (pp
, "always,from");
821 case GOMP_MAP_ALWAYS_TOFROM
:
822 pp_string (pp
, "always,tofrom");
824 case GOMP_MAP_RELEASE
:
825 pp_string (pp
, "release");
827 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
828 pp_string (pp
, "firstprivate");
830 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
831 pp_string (pp
, "firstprivate ref");
833 case GOMP_MAP_STRUCT
:
834 pp_string (pp
, "struct");
836 case GOMP_MAP_ALWAYS_POINTER
:
837 pp_string (pp
, "always_pointer");
839 case GOMP_MAP_DEVICE_RESIDENT
:
840 pp_string (pp
, "device_resident");
843 pp_string (pp
, "link");
849 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
852 if (OMP_CLAUSE_SIZE (clause
))
854 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
855 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
857 case GOMP_MAP_POINTER
:
858 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
859 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
860 case GOMP_MAP_ALWAYS_POINTER
:
861 pp_string (pp
, " [pointer assign, bias: ");
863 case GOMP_MAP_TO_PSET
:
864 pp_string (pp
, " [pointer set, len: ");
867 pp_string (pp
, " [len: ");
870 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
872 pp_right_bracket (pp
);
877 case OMP_CLAUSE_FROM
:
878 pp_string (pp
, "from(");
879 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
881 goto print_clause_size
;
884 pp_string (pp
, "to(");
885 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
887 goto print_clause_size
;
889 case OMP_CLAUSE__CACHE_
:
891 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
893 goto print_clause_size
;
895 case OMP_CLAUSE_NUM_TEAMS
:
896 pp_string (pp
, "num_teams(");
897 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
902 case OMP_CLAUSE_THREAD_LIMIT
:
903 pp_string (pp
, "thread_limit(");
904 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
909 case OMP_CLAUSE_DEVICE
:
910 pp_string (pp
, "device(");
911 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
916 case OMP_CLAUSE_DIST_SCHEDULE
:
917 pp_string (pp
, "dist_schedule(static");
918 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
921 dump_generic_node (pp
,
922 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
928 case OMP_CLAUSE_PROC_BIND
:
929 pp_string (pp
, "proc_bind(");
930 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
932 case OMP_CLAUSE_PROC_BIND_MASTER
:
933 pp_string (pp
, "master");
935 case OMP_CLAUSE_PROC_BIND_CLOSE
:
936 pp_string (pp
, "close");
938 case OMP_CLAUSE_PROC_BIND_SPREAD
:
939 pp_string (pp
, "spread");
947 case OMP_CLAUSE_SAFELEN
:
948 pp_string (pp
, "safelen(");
949 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
954 case OMP_CLAUSE_SIMDLEN
:
955 pp_string (pp
, "simdlen(");
956 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
961 case OMP_CLAUSE_PRIORITY
:
962 pp_string (pp
, "priority(");
963 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
968 case OMP_CLAUSE_GRAINSIZE
:
969 pp_string (pp
, "grainsize(");
970 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
975 case OMP_CLAUSE_NUM_TASKS
:
976 pp_string (pp
, "num_tasks(");
977 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
982 case OMP_CLAUSE_HINT
:
983 pp_string (pp
, "hint(");
984 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
989 case OMP_CLAUSE_DEFAULTMAP
:
990 pp_string (pp
, "defaultmap(");
991 switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (clause
))
993 case OMP_CLAUSE_DEFAULTMAP_ALLOC
:
994 pp_string (pp
, "alloc");
996 case OMP_CLAUSE_DEFAULTMAP_TO
:
997 pp_string (pp
, "to");
999 case OMP_CLAUSE_DEFAULTMAP_FROM
:
1000 pp_string (pp
, "from");
1002 case OMP_CLAUSE_DEFAULTMAP_TOFROM
:
1003 pp_string (pp
, "tofrom");
1005 case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE
:
1006 pp_string (pp
, "firstprivate");
1008 case OMP_CLAUSE_DEFAULTMAP_NONE
:
1009 pp_string (pp
, "none");
1011 case OMP_CLAUSE_DEFAULTMAP_DEFAULT
:
1012 pp_string (pp
, "default");
1017 switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (clause
))
1019 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED
:
1021 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR
:
1022 pp_string (pp
, ":scalar");
1024 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE
:
1025 pp_string (pp
, ":aggregate");
1027 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE
:
1028 pp_string (pp
, ":allocatable");
1030 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER
:
1031 pp_string (pp
, ":pointer");
1036 pp_right_paren (pp
);
1039 case OMP_CLAUSE__SIMDUID_
:
1040 pp_string (pp
, "_simduid_(");
1041 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
1043 pp_right_paren (pp
);
1046 case OMP_CLAUSE__SIMT_
:
1047 pp_string (pp
, "_simt_");
1050 case OMP_CLAUSE_GANG
:
1051 pp_string (pp
, "gang");
1052 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
1054 pp_string (pp
, "(num: ");
1055 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
1058 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
1060 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
1064 pp_string (pp
, "static:");
1065 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
1066 == integer_minus_one_node
)
1067 pp_character (pp
, '*');
1069 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
1072 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
1073 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
1074 pp_right_paren (pp
);
1077 case OMP_CLAUSE_ASYNC
:
1078 pp_string (pp
, "async");
1079 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
1081 pp_character(pp
, '(');
1082 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
1084 pp_character(pp
, ')');
1088 case OMP_CLAUSE_AUTO
:
1089 case OMP_CLAUSE_SEQ
:
1090 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
1093 case OMP_CLAUSE_WAIT
:
1094 pp_string (pp
, "wait(");
1095 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
1097 pp_character(pp
, ')');
1100 case OMP_CLAUSE_WORKER
:
1101 pp_string (pp
, "worker");
1102 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
1105 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
1107 pp_right_paren (pp
);
1111 case OMP_CLAUSE_VECTOR
:
1112 pp_string (pp
, "vector");
1113 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
1116 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
1118 pp_right_paren (pp
);
1122 case OMP_CLAUSE_NUM_GANGS
:
1123 pp_string (pp
, "num_gangs(");
1124 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
1126 pp_character (pp
, ')');
1129 case OMP_CLAUSE_NUM_WORKERS
:
1130 pp_string (pp
, "num_workers(");
1131 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
1133 pp_character (pp
, ')');
1136 case OMP_CLAUSE_VECTOR_LENGTH
:
1137 pp_string (pp
, "vector_length(");
1138 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
1140 pp_character (pp
, ')');
1143 case OMP_CLAUSE_INBRANCH
:
1144 pp_string (pp
, "inbranch");
1146 case OMP_CLAUSE_NOTINBRANCH
:
1147 pp_string (pp
, "notinbranch");
1149 case OMP_CLAUSE_FOR
:
1150 pp_string (pp
, "for");
1152 case OMP_CLAUSE_PARALLEL
:
1153 pp_string (pp
, "parallel");
1155 case OMP_CLAUSE_SECTIONS
:
1156 pp_string (pp
, "sections");
1158 case OMP_CLAUSE_TASKGROUP
:
1159 pp_string (pp
, "taskgroup");
1161 case OMP_CLAUSE_NOGROUP
:
1162 pp_string (pp
, "nogroup");
1164 case OMP_CLAUSE_THREADS
:
1165 pp_string (pp
, "threads");
1167 case OMP_CLAUSE_SIMD
:
1168 pp_string (pp
, "simd");
1170 case OMP_CLAUSE_INDEPENDENT
:
1171 pp_string (pp
, "independent");
1173 case OMP_CLAUSE_TILE
:
1174 pp_string (pp
, "tile(");
1175 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1177 pp_right_paren (pp
);
1180 case OMP_CLAUSE__GRIDDIM_
:
1181 pp_string (pp
, "_griddim_(");
1182 pp_unsigned_wide_integer (pp
, OMP_CLAUSE__GRIDDIM__DIMENSION (clause
));
1184 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__SIZE (clause
), spc
, flags
,
1187 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__GROUP (clause
), spc
, flags
,
1189 pp_right_paren (pp
);
1191 case OMP_CLAUSE_IF_PRESENT
:
1192 pp_string (pp
, "if_present");
1194 case OMP_CLAUSE_FINALIZE
:
1195 pp_string (pp
, "finalize");
1204 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1205 dump_generic_node. */
1208 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
1216 dump_omp_clause (pp
, clause
, spc
, flags
);
1217 clause
= OMP_CLAUSE_CHAIN (clause
);
1225 /* Dump location LOC to PP. */
1228 dump_location (pretty_printer
*pp
, location_t loc
)
1230 expanded_location xloc
= expand_location (loc
);
1232 pp_left_bracket (pp
);
1235 pp_string (pp
, xloc
.file
);
1236 pp_string (pp
, ":");
1238 pp_decimal_int (pp
, xloc
.line
);
1240 pp_decimal_int (pp
, xloc
.column
);
1241 pp_string (pp
, "] ");
1245 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1246 dump_generic_node. */
1249 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, dump_flags_t flags
)
1253 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1255 if (flags
& TDF_ADDRESS
)
1256 pp_printf (pp
, "[%p] ", (void *) block
);
1258 if (TREE_ASM_WRITTEN (block
))
1259 pp_string (pp
, "[written] ");
1261 if (flags
& TDF_SLIM
)
1264 if (BLOCK_SOURCE_LOCATION (block
))
1265 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1267 newline_and_indent (pp
, spc
+ 2);
1269 if (BLOCK_SUPERCONTEXT (block
))
1271 pp_string (pp
, "SUPERCONTEXT: ");
1272 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1273 flags
| TDF_SLIM
, false);
1274 newline_and_indent (pp
, spc
+ 2);
1277 if (BLOCK_SUBBLOCKS (block
))
1279 pp_string (pp
, "SUBBLOCKS: ");
1280 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1282 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1285 newline_and_indent (pp
, spc
+ 2);
1288 if (BLOCK_CHAIN (block
))
1290 pp_string (pp
, "SIBLINGS: ");
1291 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1293 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1296 newline_and_indent (pp
, spc
+ 2);
1299 if (BLOCK_VARS (block
))
1301 pp_string (pp
, "VARS: ");
1302 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1304 dump_generic_node (pp
, t
, 0, flags
, false);
1307 newline_and_indent (pp
, spc
+ 2);
1310 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1313 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1315 pp_string (pp
, "NONLOCALIZED_VARS: ");
1316 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1318 dump_generic_node (pp
, t
, 0, flags
, false);
1321 newline_and_indent (pp
, spc
+ 2);
1324 if (BLOCK_ABSTRACT_ORIGIN (block
))
1326 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1327 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1328 flags
| TDF_SLIM
, false);
1329 newline_and_indent (pp
, spc
+ 2);
1332 if (BLOCK_FRAGMENT_ORIGIN (block
))
1334 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1335 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1336 flags
| TDF_SLIM
, false);
1337 newline_and_indent (pp
, spc
+ 2);
1340 if (BLOCK_FRAGMENT_CHAIN (block
))
1342 pp_string (pp
, "FRAGMENT_CHAIN: ");
1343 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1345 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1348 newline_and_indent (pp
, spc
+ 2);
1352 /* Dump #pragma omp atomic memory order clause. */
1355 dump_omp_atomic_memory_order (pretty_printer
*pp
, enum omp_memory_order mo
)
1359 case OMP_MEMORY_ORDER_RELAXED
:
1360 pp_string (pp
, " relaxed");
1362 case OMP_MEMORY_ORDER_SEQ_CST
:
1363 pp_string (pp
, " seq_cst");
1365 case OMP_MEMORY_ORDER_ACQ_REL
:
1366 pp_string (pp
, " acq_rel");
1368 case OMP_MEMORY_ORDER_ACQUIRE
:
1369 pp_string (pp
, " acquire");
1371 case OMP_MEMORY_ORDER_RELEASE
:
1372 pp_string (pp
, " release");
1374 case OMP_MEMORY_ORDER_UNSPECIFIED
:
1381 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1382 indent. FLAGS specifies details to show in the dump (see TDF_* in
1383 dumpfile.h). If IS_STMT is true, the object printed is considered
1384 to be a statement and it is terminated by ';' if appropriate. */
1387 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
,
1394 enum tree_code code
;
1396 if (node
== NULL_TREE
)
1399 is_expr
= EXPR_P (node
);
1401 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1402 pp_printf (pp
, "<&%p> ", (void *)node
);
1404 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1405 dump_location (pp
, EXPR_LOCATION (node
));
1407 code
= TREE_CODE (node
);
1411 pp_string (pp
, "<<< error >>>");
1414 case IDENTIFIER_NODE
:
1415 pp_tree_identifier (pp
, node
);
1419 while (node
&& node
!= error_mark_node
)
1421 if (TREE_PURPOSE (node
))
1423 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1426 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1427 node
= TREE_CHAIN (node
);
1428 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1437 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1443 if (TREE_VEC_LENGTH (node
) > 0)
1445 size_t len
= TREE_VEC_LENGTH (node
);
1446 for (i
= 0; i
< len
- 1; i
++)
1448 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1453 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1462 case FIXED_POINT_TYPE
:
1468 unsigned int quals
= TYPE_QUALS (node
);
1469 enum tree_code_class tclass
;
1471 if (quals
& TYPE_QUAL_ATOMIC
)
1472 pp_string (pp
, "atomic ");
1473 if (quals
& TYPE_QUAL_CONST
)
1474 pp_string (pp
, "const ");
1475 else if (quals
& TYPE_QUAL_VOLATILE
)
1476 pp_string (pp
, "volatile ");
1477 else if (quals
& TYPE_QUAL_RESTRICT
)
1478 pp_string (pp
, "restrict ");
1480 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1482 pp_string (pp
, "<address-space-");
1483 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1484 pp_string (pp
, "> ");
1487 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1489 if (tclass
== tcc_declaration
)
1491 if (DECL_NAME (node
))
1492 dump_decl_name (pp
, node
, flags
);
1494 pp_string (pp
, "<unnamed type decl>");
1496 else if (tclass
== tcc_type
)
1498 if (TYPE_NAME (node
))
1500 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1501 pp_tree_identifier (pp
, TYPE_NAME (node
));
1502 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1503 && DECL_NAME (TYPE_NAME (node
)))
1504 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1506 pp_string (pp
, "<unnamed type>");
1508 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1510 pp_string (pp
, "vector");
1512 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1513 pp_string (pp
, ") ");
1514 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1516 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1518 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1519 pp_string (pp
, (TYPE_UNSIGNED (node
)
1522 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1523 pp_string (pp
, (TYPE_UNSIGNED (node
)
1526 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1527 pp_string (pp
, (TYPE_UNSIGNED (node
)
1530 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1531 pp_string (pp
, (TYPE_UNSIGNED (node
)
1534 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1535 pp_string (pp
, (TYPE_UNSIGNED (node
)
1536 ? "unsigned long long"
1537 : "signed long long"));
1538 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1539 && pow2p_hwi (TYPE_PRECISION (node
)))
1541 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1542 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1543 pp_string (pp
, "_t");
1547 pp_string (pp
, (TYPE_UNSIGNED (node
)
1548 ? "<unnamed-unsigned:"
1549 : "<unnamed-signed:"));
1550 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1554 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1556 pp_string (pp
, "__complex__ ");
1557 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1559 else if (TREE_CODE (node
) == REAL_TYPE
)
1561 pp_string (pp
, "<float:");
1562 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1565 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1567 pp_string (pp
, "<fixed-point-");
1568 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1569 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1572 else if (TREE_CODE (node
) == VOID_TYPE
)
1573 pp_string (pp
, "void");
1575 pp_string (pp
, "<unnamed type>");
1581 case REFERENCE_TYPE
:
1582 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1584 if (TREE_TYPE (node
) == NULL
)
1586 pp_string (pp
, str
);
1587 pp_string (pp
, "<null type>");
1589 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1591 tree fnode
= TREE_TYPE (node
);
1593 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1596 pp_string (pp
, str
);
1597 if (TYPE_IDENTIFIER (node
))
1598 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1599 else if (flags
& TDF_NOUID
)
1600 pp_printf (pp
, "<Txxxx>");
1602 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1604 pp_right_paren (pp
);
1605 dump_function_declaration (pp
, fnode
, spc
, flags
);
1609 unsigned int quals
= TYPE_QUALS (node
);
1611 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1613 pp_string (pp
, str
);
1615 if (quals
& TYPE_QUAL_CONST
)
1616 pp_string (pp
, " const");
1617 if (quals
& TYPE_QUAL_VOLATILE
)
1618 pp_string (pp
, " volatile");
1619 if (quals
& TYPE_QUAL_RESTRICT
)
1620 pp_string (pp
, " restrict");
1622 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1624 pp_string (pp
, " <address-space-");
1625 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1629 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1630 pp_string (pp
, " {ref-all}");
1640 if (flags
& TDF_GIMPLE
)
1642 pp_string (pp
, "__MEM <");
1643 dump_generic_node (pp
, TREE_TYPE (node
),
1644 spc
, flags
| TDF_SLIM
, false);
1645 if (TYPE_ALIGN (TREE_TYPE (node
))
1646 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
1648 pp_string (pp
, ", ");
1649 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
1652 pp_string (pp
, " (");
1653 if (TREE_TYPE (TREE_OPERAND (node
, 0))
1654 != TREE_TYPE (TREE_OPERAND (node
, 1)))
1657 dump_generic_node (pp
, TREE_TYPE (TREE_OPERAND (node
, 1)),
1658 spc
, flags
| TDF_SLIM
, false);
1659 pp_right_paren (pp
);
1661 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1662 spc
, flags
| TDF_SLIM
, false);
1663 if (! integer_zerop (TREE_OPERAND (node
, 1)))
1665 pp_string (pp
, " + ");
1666 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1667 spc
, flags
| TDF_SLIM
, false);
1669 pp_right_paren (pp
);
1671 else if (integer_zerop (TREE_OPERAND (node
, 1))
1672 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1673 infer them and MEM_ATTR caching will share MEM_REFs
1674 with differently-typed op0s. */
1675 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1676 /* Released SSA_NAMES have no TREE_TYPE. */
1677 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1678 /* Same pointer types, but ignoring POINTER_TYPE vs.
1680 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1681 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1682 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1683 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1684 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1685 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1686 /* Same value types ignoring qualifiers. */
1687 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1688 == TYPE_MAIN_VARIANT
1689 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1690 && (!(flags
& TDF_ALIAS
)
1691 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1693 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1695 /* Enclose pointers to arrays in parentheses. */
1696 tree op0
= TREE_OPERAND (node
, 0);
1697 tree op0type
= TREE_TYPE (op0
);
1698 if (POINTER_TYPE_P (op0type
)
1699 && TREE_CODE (TREE_TYPE (op0type
)) == ARRAY_TYPE
)
1702 dump_generic_node (pp
, op0
, spc
, flags
, false);
1703 if (POINTER_TYPE_P (op0type
)
1704 && TREE_CODE (TREE_TYPE (op0type
)) == ARRAY_TYPE
)
1705 pp_right_paren (pp
);
1708 dump_generic_node (pp
,
1709 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1716 pp_string (pp
, "MEM[");
1718 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1719 dump_generic_node (pp
, ptype
,
1720 spc
, flags
| TDF_SLIM
, false);
1721 pp_right_paren (pp
);
1722 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1724 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1726 pp_string (pp
, " + ");
1727 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1730 if ((flags
& TDF_ALIAS
)
1731 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1733 pp_string (pp
, " clique ");
1734 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1735 pp_string (pp
, " base ");
1736 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1738 pp_right_bracket (pp
);
1743 case TARGET_MEM_REF
:
1745 const char *sep
= "";
1748 pp_string (pp
, "MEM[");
1750 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1752 pp_string (pp
, sep
);
1754 pp_string (pp
, "symbol: ");
1755 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1760 pp_string (pp
, sep
);
1762 pp_string (pp
, "base: ");
1763 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1765 tmp
= TMR_INDEX2 (node
);
1768 pp_string (pp
, sep
);
1770 pp_string (pp
, "base: ");
1771 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1773 tmp
= TMR_INDEX (node
);
1776 pp_string (pp
, sep
);
1778 pp_string (pp
, "index: ");
1779 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1781 tmp
= TMR_STEP (node
);
1784 pp_string (pp
, sep
);
1786 pp_string (pp
, "step: ");
1787 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1789 tmp
= TMR_OFFSET (node
);
1792 pp_string (pp
, sep
);
1794 pp_string (pp
, "offset: ");
1795 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1797 pp_right_bracket (pp
);
1805 /* Print the innermost component type. */
1806 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1807 tmp
= TREE_TYPE (tmp
))
1809 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1811 /* Print the dimensions. */
1812 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1813 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1819 case QUAL_UNION_TYPE
:
1821 unsigned int quals
= TYPE_QUALS (node
);
1823 if (quals
& TYPE_QUAL_ATOMIC
)
1824 pp_string (pp
, "atomic ");
1825 if (quals
& TYPE_QUAL_CONST
)
1826 pp_string (pp
, "const ");
1827 if (quals
& TYPE_QUAL_VOLATILE
)
1828 pp_string (pp
, "volatile ");
1830 /* Print the name of the structure. */
1831 if (TREE_CODE (node
) == RECORD_TYPE
)
1832 pp_string (pp
, "struct ");
1833 else if (TREE_CODE (node
) == UNION_TYPE
)
1834 pp_string (pp
, "union ");
1836 if (TYPE_NAME (node
))
1837 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1838 else if (!(flags
& TDF_SLIM
))
1839 /* FIXME: If we eliminate the 'else' above and attempt
1840 to show the fields for named types, we may get stuck
1841 following a cycle of pointers to structs. The alleged
1842 self-reference check in print_struct_decl will not detect
1843 cycles involving more than one pointer or struct type. */
1844 print_struct_decl (pp
, node
, spc
, flags
);
1853 if (flags
& TDF_GIMPLE
1854 && (POINTER_TYPE_P (TREE_TYPE (node
))
1855 || (TYPE_PRECISION (TREE_TYPE (node
))
1856 < TYPE_PRECISION (integer_type_node
))
1857 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1
1858 || tree_int_cst_sgn (node
) < 0))
1860 pp_string (pp
, "_Literal (");
1861 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1862 pp_string (pp
, ") ");
1864 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
1865 && ! (flags
& TDF_GIMPLE
))
1867 /* In the case of a pointer, one may want to divide by the
1868 size of the pointed-to type. Unfortunately, this not
1869 straightforward. The C front-end maps expressions
1874 in such a way that the two INTEGER_CST nodes for "5" have
1875 different values but identical types. In the latter
1876 case, the 5 is multiplied by sizeof (int) in c-common.c
1877 (pointer_int_sum) to convert it to a byte address, and
1878 yet the type of the node is left unchanged. Argh. What
1879 is consistent though is that the number value corresponds
1880 to bytes (UNITS) offset.
1882 NB: Neither of the following divisors can be trivially
1883 used to recover the original literal:
1885 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1886 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1887 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1888 pp_string (pp
, "B"); /* pseudo-unit */
1890 else if (tree_fits_shwi_p (node
))
1891 pp_wide_integer (pp
, tree_to_shwi (node
));
1892 else if (tree_fits_uhwi_p (node
))
1893 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1896 wide_int val
= wi::to_wide (node
);
1898 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1903 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
1904 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
1906 if ((flags
& TDF_GIMPLE
)
1907 && ! (POINTER_TYPE_P (TREE_TYPE (node
))
1908 || (TYPE_PRECISION (TREE_TYPE (node
))
1909 < TYPE_PRECISION (integer_type_node
))
1910 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1912 if (TYPE_UNSIGNED (TREE_TYPE (node
)))
1913 pp_character (pp
, 'u');
1914 if (TYPE_PRECISION (TREE_TYPE (node
))
1915 == TYPE_PRECISION (unsigned_type_node
))
1917 else if (TYPE_PRECISION (TREE_TYPE (node
))
1918 == TYPE_PRECISION (long_unsigned_type_node
))
1919 pp_character (pp
, 'l');
1920 else if (TYPE_PRECISION (TREE_TYPE (node
))
1921 == TYPE_PRECISION (long_long_unsigned_type_node
))
1922 pp_string (pp
, "ll");
1924 if (TREE_OVERFLOW (node
))
1925 pp_string (pp
, "(OVF)");
1929 pp_string (pp
, "POLY_INT_CST [");
1930 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, 0), spc
, flags
, false);
1931 for (unsigned int i
= 1; i
< NUM_POLY_INT_COEFFS
; ++i
)
1933 pp_string (pp
, ", ");
1934 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, i
),
1937 pp_string (pp
, "]");
1941 /* Code copied from print_node. */
1944 if (TREE_OVERFLOW (node
))
1945 pp_string (pp
, " overflow");
1947 d
= TREE_REAL_CST (node
);
1948 if (REAL_VALUE_ISINF (d
))
1949 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1950 else if (REAL_VALUE_ISNAN (d
))
1951 pp_string (pp
, " Nan");
1955 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1956 pp_string (pp
, string
);
1964 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1965 pp_string (pp
, string
);
1970 pp_string (pp
, "__complex__ (");
1971 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
1972 pp_string (pp
, ", ");
1973 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
1974 pp_right_paren (pp
);
1979 pp_string (pp
, "\"");
1980 if (unsigned nbytes
= TREE_STRING_LENGTH (node
))
1981 pretty_print_string (pp
, TREE_STRING_POINTER (node
), nbytes
);
1982 pp_string (pp
, "\"");
1989 pp_string (pp
, "{ ");
1990 unsigned HOST_WIDE_INT nunits
;
1991 if (!VECTOR_CST_NELTS (node
).is_constant (&nunits
))
1992 nunits
= vector_cst_encoded_nelts (node
);
1993 for (i
= 0; i
< nunits
; ++i
)
1996 pp_string (pp
, ", ");
1997 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
2000 if (!VECTOR_CST_NELTS (node
).is_constant ())
2001 pp_string (pp
, ", ...");
2002 pp_string (pp
, " }");
2008 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2010 if (TREE_CODE (node
) == METHOD_TYPE
)
2012 if (TYPE_METHOD_BASETYPE (node
))
2013 dump_generic_node (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
2016 pp_string (pp
, "<null method basetype>");
2017 pp_colon_colon (pp
);
2019 if (TYPE_IDENTIFIER (node
))
2020 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
2021 else if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
2022 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
2023 else if (flags
& TDF_NOUID
)
2024 pp_printf (pp
, "<Txxxx>");
2026 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
2027 dump_function_declaration (pp
, node
, spc
, flags
);
2032 dump_decl_name (pp
, node
, flags
);
2036 if (DECL_NAME (node
))
2037 dump_decl_name (pp
, node
, flags
);
2038 else if (LABEL_DECL_UID (node
) != -1)
2040 if (flags
& TDF_GIMPLE
)
2041 pp_printf (pp
, "L%d", (int) LABEL_DECL_UID (node
));
2043 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
2047 if (flags
& TDF_NOUID
)
2048 pp_string (pp
, "<D.xxxx>");
2051 if (flags
& TDF_GIMPLE
)
2052 pp_printf (pp
, "<D%u>", DECL_UID (node
));
2054 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
2060 if (DECL_IS_BUILTIN (node
))
2062 /* Don't print the declaration of built-in types. */
2065 if (DECL_NAME (node
))
2066 dump_decl_name (pp
, node
, flags
);
2067 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
2069 pp_string (pp
, (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
2070 ? "union" : "struct "));
2071 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2074 pp_string (pp
, "<anon>");
2080 case DEBUG_EXPR_DECL
:
2081 case NAMESPACE_DECL
:
2083 dump_decl_name (pp
, node
, flags
);
2087 pp_string (pp
, "<retval>");
2091 op0
= TREE_OPERAND (node
, 0);
2094 && (TREE_CODE (op0
) == INDIRECT_REF
2095 || (TREE_CODE (op0
) == MEM_REF
2096 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
2097 && integer_zerop (TREE_OPERAND (op0
, 1))
2098 /* Dump the types of INTEGER_CSTs explicitly, for we
2099 can't infer them and MEM_ATTR caching will share
2100 MEM_REFs with differently-typed op0s. */
2101 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
2102 /* Released SSA_NAMES have no TREE_TYPE. */
2103 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
2104 /* Same pointer types, but ignoring POINTER_TYPE vs.
2106 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2107 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2108 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2109 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2110 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2111 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2112 /* Same value types ignoring qualifiers. */
2113 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
2114 == TYPE_MAIN_VARIANT
2115 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
2116 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
2118 op0
= TREE_OPERAND (op0
, 0);
2121 if (op_prio (op0
) < op_prio (node
))
2123 dump_generic_node (pp
, op0
, spc
, flags
, false);
2124 if (op_prio (op0
) < op_prio (node
))
2125 pp_right_paren (pp
);
2126 pp_string (pp
, str
);
2127 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2128 op0
= component_ref_field_offset (node
);
2129 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
2131 pp_string (pp
, "{off: ");
2132 dump_generic_node (pp
, op0
, spc
, flags
, false);
2133 pp_right_brace (pp
);
2138 if (flags
& TDF_GIMPLE
)
2140 pp_string (pp
, "__BIT_FIELD_REF <");
2141 dump_generic_node (pp
, TREE_TYPE (node
),
2142 spc
, flags
| TDF_SLIM
, false);
2143 if (TYPE_ALIGN (TREE_TYPE (node
))
2144 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
2146 pp_string (pp
, ", ");
2147 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
2150 pp_string (pp
, " (");
2151 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
,
2152 flags
| TDF_SLIM
, false);
2153 pp_string (pp
, ", ");
2154 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
,
2155 flags
| TDF_SLIM
, false);
2156 pp_string (pp
, ", ");
2157 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
,
2158 flags
| TDF_SLIM
, false);
2159 pp_right_paren (pp
);
2163 pp_string (pp
, "BIT_FIELD_REF <");
2164 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2165 pp_string (pp
, ", ");
2166 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2167 pp_string (pp
, ", ");
2168 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2173 case BIT_INSERT_EXPR
:
2174 pp_string (pp
, "BIT_INSERT_EXPR <");
2175 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2176 pp_string (pp
, ", ");
2177 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2178 pp_string (pp
, ", ");
2179 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2180 pp_string (pp
, " (");
2181 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
2183 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
2185 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
2187 pp_string (pp
, " bits)>");
2191 case ARRAY_RANGE_REF
:
2192 op0
= TREE_OPERAND (node
, 0);
2193 if (op_prio (op0
) < op_prio (node
))
2195 dump_generic_node (pp
, op0
, spc
, flags
, false);
2196 if (op_prio (op0
) < op_prio (node
))
2197 pp_right_paren (pp
);
2198 pp_left_bracket (pp
);
2199 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2200 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
2201 pp_string (pp
, " ...");
2202 pp_right_bracket (pp
);
2204 op0
= array_ref_low_bound (node
);
2205 op1
= array_ref_element_size (node
);
2207 if (!integer_zerop (op0
)
2208 || TREE_OPERAND (node
, 2)
2209 || TREE_OPERAND (node
, 3))
2211 pp_string (pp
, "{lb: ");
2212 dump_generic_node (pp
, op0
, spc
, flags
, false);
2213 pp_string (pp
, " sz: ");
2214 dump_generic_node (pp
, op1
, spc
, flags
, false);
2215 pp_right_brace (pp
);
2221 unsigned HOST_WIDE_INT ix
;
2223 bool is_struct_init
= false;
2224 bool is_array_init
= false;
2227 if (TREE_CLOBBER_P (node
))
2228 pp_string (pp
, "CLOBBER");
2229 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
2230 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
2231 is_struct_init
= true;
2232 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
2233 && TYPE_DOMAIN (TREE_TYPE (node
))
2234 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
2235 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
2238 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
2239 is_array_init
= true;
2240 curidx
= wi::to_widest (minv
);
2242 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
2249 dump_generic_node (pp
, field
, spc
, flags
, false);
2252 else if (is_array_init
2253 && (TREE_CODE (field
) != INTEGER_CST
2254 || curidx
!= wi::to_widest (field
)))
2256 pp_left_bracket (pp
);
2257 if (TREE_CODE (field
) == RANGE_EXPR
)
2259 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
2261 pp_string (pp
, " ... ");
2262 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
2264 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
2265 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
2268 dump_generic_node (pp
, field
, spc
, flags
, false);
2269 if (TREE_CODE (field
) == INTEGER_CST
)
2270 curidx
= wi::to_widest (field
);
2271 pp_string (pp
, "]=");
2276 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
2277 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
2278 val
= TREE_OPERAND (val
, 0);
2279 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
2280 dump_decl_name (pp
, val
, flags
);
2282 dump_generic_node (pp
, val
, spc
, flags
, false);
2283 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2289 pp_right_brace (pp
);
2296 if (flags
& TDF_SLIM
)
2298 pp_string (pp
, "<COMPOUND_EXPR>");
2302 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2303 spc
, flags
, !(flags
& TDF_SLIM
));
2304 if (flags
& TDF_SLIM
)
2305 newline_and_indent (pp
, spc
);
2312 for (tp
= &TREE_OPERAND (node
, 1);
2313 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2314 tp
= &TREE_OPERAND (*tp
, 1))
2316 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2317 spc
, flags
, !(flags
& TDF_SLIM
));
2318 if (flags
& TDF_SLIM
)
2319 newline_and_indent (pp
, spc
);
2327 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2331 case STATEMENT_LIST
:
2333 tree_stmt_iterator si
;
2336 if (flags
& TDF_SLIM
)
2338 pp_string (pp
, "<STATEMENT_LIST>");
2342 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2345 newline_and_indent (pp
, spc
);
2348 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2355 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2360 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2365 pp_string (pp
, "TARGET_EXPR <");
2366 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2369 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2374 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2379 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2381 pp_string (pp
, "if (");
2382 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2383 pp_right_paren (pp
);
2384 /* The lowered cond_exprs should always be printed in full. */
2385 if (COND_EXPR_THEN (node
)
2386 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2387 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2388 && COND_EXPR_ELSE (node
)
2389 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2390 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2393 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2395 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2397 pp_string (pp
, " else ");
2398 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2402 else if (!(flags
& TDF_SLIM
))
2404 /* Output COND_EXPR_THEN. */
2405 if (COND_EXPR_THEN (node
))
2407 newline_and_indent (pp
, spc
+2);
2409 newline_and_indent (pp
, spc
+4);
2410 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2412 newline_and_indent (pp
, spc
+2);
2413 pp_right_brace (pp
);
2416 /* Output COND_EXPR_ELSE. */
2417 if (COND_EXPR_ELSE (node
)
2418 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2420 newline_and_indent (pp
, spc
);
2421 pp_string (pp
, "else");
2422 newline_and_indent (pp
, spc
+2);
2424 newline_and_indent (pp
, spc
+4);
2425 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2427 newline_and_indent (pp
, spc
+2);
2428 pp_right_brace (pp
);
2435 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2439 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2443 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2449 if (!(flags
& TDF_SLIM
))
2451 if (BIND_EXPR_VARS (node
))
2455 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2457 print_declaration (pp
, op0
, spc
+2, flags
);
2462 newline_and_indent (pp
, spc
+2);
2463 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2464 newline_and_indent (pp
, spc
);
2465 pp_right_brace (pp
);
2471 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2472 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2476 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2479 /* Print parameters. */
2484 call_expr_arg_iterator iter
;
2485 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2487 dump_generic_node (pp
, arg
, spc
, flags
, false);
2488 if (more_call_expr_args_p (&iter
))
2495 if (CALL_EXPR_VA_ARG_PACK (node
))
2497 if (call_expr_nargs (node
) > 0)
2502 pp_string (pp
, "__builtin_va_arg_pack ()");
2504 pp_right_paren (pp
);
2506 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2509 pp_string (pp
, " [static-chain: ");
2510 dump_generic_node (pp
, op1
, spc
, flags
, false);
2511 pp_right_bracket (pp
);
2514 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2515 pp_string (pp
, " [return slot optimization]");
2516 if (CALL_EXPR_TAILCALL (node
))
2517 pp_string (pp
, " [tail call]");
2520 case WITH_CLEANUP_EXPR
:
2524 case CLEANUP_POINT_EXPR
:
2525 pp_string (pp
, "<<cleanup_point ");
2526 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2527 pp_string (pp
, ">>");
2530 case PLACEHOLDER_EXPR
:
2531 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2532 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2536 /* Binary arithmetic and logic expressions. */
2537 case WIDEN_SUM_EXPR
:
2538 case WIDEN_MULT_EXPR
:
2540 case MULT_HIGHPART_EXPR
:
2542 case POINTER_PLUS_EXPR
:
2543 case POINTER_DIFF_EXPR
:
2545 case TRUNC_DIV_EXPR
:
2547 case FLOOR_DIV_EXPR
:
2548 case ROUND_DIV_EXPR
:
2549 case TRUNC_MOD_EXPR
:
2551 case FLOOR_MOD_EXPR
:
2552 case ROUND_MOD_EXPR
:
2554 case EXACT_DIV_EXPR
:
2559 case WIDEN_LSHIFT_EXPR
:
2563 case TRUTH_ANDIF_EXPR
:
2564 case TRUTH_ORIF_EXPR
:
2565 case TRUTH_AND_EXPR
:
2567 case TRUTH_XOR_EXPR
:
2581 case UNORDERED_EXPR
:
2583 const char *op
= op_symbol (node
);
2584 op0
= TREE_OPERAND (node
, 0);
2585 op1
= TREE_OPERAND (node
, 1);
2587 /* When the operands are expressions with less priority,
2588 keep semantics of the tree representation. */
2589 if (op_prio (op0
) <= op_prio (node
))
2592 dump_generic_node (pp
, op0
, spc
, flags
, false);
2593 pp_right_paren (pp
);
2596 dump_generic_node (pp
, op0
, spc
, flags
, false);
2602 /* When the operands are expressions with less priority,
2603 keep semantics of the tree representation. */
2604 if (op_prio (op1
) <= op_prio (node
))
2607 dump_generic_node (pp
, op1
, spc
, flags
, false);
2608 pp_right_paren (pp
);
2611 dump_generic_node (pp
, op1
, spc
, flags
, false);
2615 /* Unary arithmetic and logic expressions. */
2618 case TRUTH_NOT_EXPR
:
2620 case PREDECREMENT_EXPR
:
2621 case PREINCREMENT_EXPR
:
2623 if (TREE_CODE (node
) == ADDR_EXPR
2624 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2625 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2626 ; /* Do not output '&' for strings and function pointers. */
2628 pp_string (pp
, op_symbol (node
));
2630 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2633 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2634 pp_right_paren (pp
);
2637 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2640 case POSTDECREMENT_EXPR
:
2641 case POSTINCREMENT_EXPR
:
2642 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2645 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2646 pp_right_paren (pp
);
2649 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2650 pp_string (pp
, op_symbol (node
));
2654 pp_string (pp
, "MIN_EXPR <");
2655 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2656 pp_string (pp
, ", ");
2657 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2662 pp_string (pp
, "MAX_EXPR <");
2663 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2664 pp_string (pp
, ", ");
2665 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2670 pp_string (pp
, "ABS_EXPR <");
2671 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2676 pp_string (pp
, "ABSU_EXPR <");
2677 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2685 case ADDR_SPACE_CONVERT_EXPR
:
2686 case FIXED_CONVERT_EXPR
:
2687 case FIX_TRUNC_EXPR
:
2690 type
= TREE_TYPE (node
);
2691 op0
= TREE_OPERAND (node
, 0);
2692 if (type
!= TREE_TYPE (op0
))
2695 dump_generic_node (pp
, type
, spc
, flags
, false);
2696 pp_string (pp
, ") ");
2698 if (op_prio (op0
) < op_prio (node
))
2700 dump_generic_node (pp
, op0
, spc
, flags
, false);
2701 if (op_prio (op0
) < op_prio (node
))
2702 pp_right_paren (pp
);
2705 case VIEW_CONVERT_EXPR
:
2706 if (flags
& TDF_GIMPLE
)
2707 pp_string (pp
, "__VIEW_CONVERT <");
2709 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2710 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2711 pp_string (pp
, ">(");
2712 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2713 pp_right_paren (pp
);
2717 pp_string (pp
, "((");
2718 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2719 pp_string (pp
, "))");
2722 case NON_LVALUE_EXPR
:
2723 pp_string (pp
, "NON_LVALUE_EXPR <");
2724 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2729 pp_string (pp
, "SAVE_EXPR <");
2730 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2735 pp_string (pp
, "COMPLEX_EXPR <");
2736 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2737 pp_string (pp
, ", ");
2738 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2743 pp_string (pp
, "CONJ_EXPR <");
2744 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2749 if (flags
& TDF_GIMPLE
)
2751 pp_string (pp
, "__real ");
2752 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2756 pp_string (pp
, "REALPART_EXPR <");
2757 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2763 if (flags
& TDF_GIMPLE
)
2765 pp_string (pp
, "__imag ");
2766 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2770 pp_string (pp
, "IMAGPART_EXPR <");
2771 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2777 pp_string (pp
, "VA_ARG_EXPR <");
2778 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2782 case TRY_FINALLY_EXPR
:
2783 case TRY_CATCH_EXPR
:
2784 pp_string (pp
, "try");
2785 newline_and_indent (pp
, spc
+2);
2787 newline_and_indent (pp
, spc
+4);
2788 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2789 newline_and_indent (pp
, spc
+2);
2790 pp_right_brace (pp
);
2791 newline_and_indent (pp
, spc
);
2793 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2794 newline_and_indent (pp
, spc
+2);
2796 newline_and_indent (pp
, spc
+4);
2797 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2798 newline_and_indent (pp
, spc
+2);
2799 pp_right_brace (pp
);
2804 pp_string (pp
, "catch (");
2805 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2806 pp_right_paren (pp
);
2807 newline_and_indent (pp
, spc
+2);
2809 newline_and_indent (pp
, spc
+4);
2810 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2811 newline_and_indent (pp
, spc
+2);
2812 pp_right_brace (pp
);
2816 case EH_FILTER_EXPR
:
2817 pp_string (pp
, "<<<eh_filter (");
2818 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2819 pp_string (pp
, ")>>>");
2820 newline_and_indent (pp
, spc
+2);
2822 newline_and_indent (pp
, spc
+4);
2823 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2824 newline_and_indent (pp
, spc
+2);
2825 pp_right_brace (pp
);
2830 op0
= TREE_OPERAND (node
, 0);
2831 /* If this is for break or continue, don't bother printing it. */
2832 if (DECL_NAME (op0
))
2834 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2835 if (strcmp (name
, "break") == 0
2836 || strcmp (name
, "continue") == 0)
2839 dump_generic_node (pp
, op0
, spc
, flags
, false);
2841 if (DECL_NONLOCAL (op0
))
2842 pp_string (pp
, " [non-local]");
2846 pp_string (pp
, "while (1)");
2847 if (!(flags
& TDF_SLIM
))
2849 newline_and_indent (pp
, spc
+2);
2851 newline_and_indent (pp
, spc
+4);
2852 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2853 newline_and_indent (pp
, spc
+2);
2854 pp_right_brace (pp
);
2860 pp_string (pp
, "// predicted ");
2861 if (PREDICT_EXPR_OUTCOME (node
))
2862 pp_string (pp
, "likely by ");
2864 pp_string (pp
, "unlikely by ");
2865 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2866 pp_string (pp
, " predictor.");
2870 pp_string (pp
, "ANNOTATE_EXPR <");
2871 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2872 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2874 case annot_expr_ivdep_kind
:
2875 pp_string (pp
, ", ivdep");
2877 case annot_expr_unroll_kind
:
2878 pp_printf (pp
, ", unroll %d",
2879 (int) TREE_INT_CST_LOW (TREE_OPERAND (node
, 2)));
2881 case annot_expr_no_vector_kind
:
2882 pp_string (pp
, ", no-vector");
2884 case annot_expr_vector_kind
:
2885 pp_string (pp
, ", vector");
2887 case annot_expr_parallel_kind
:
2888 pp_string (pp
, ", parallel");
2897 pp_string (pp
, "return");
2898 op0
= TREE_OPERAND (node
, 0);
2902 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2903 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2906 dump_generic_node (pp
, op0
, spc
, flags
, false);
2911 pp_string (pp
, "if (");
2912 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2913 pp_string (pp
, ") break");
2917 pp_string (pp
, "switch (");
2918 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2919 pp_right_paren (pp
);
2920 if (!(flags
& TDF_SLIM
))
2922 newline_and_indent (pp
, spc
+2);
2924 if (SWITCH_BODY (node
))
2926 newline_and_indent (pp
, spc
+4);
2927 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2930 newline_and_indent (pp
, spc
+2);
2931 pp_right_brace (pp
);
2937 op0
= GOTO_DESTINATION (node
);
2938 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2940 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2941 if (strcmp (name
, "break") == 0
2942 || strcmp (name
, "continue") == 0)
2944 pp_string (pp
, name
);
2948 pp_string (pp
, "goto ");
2949 dump_generic_node (pp
, op0
, spc
, flags
, false);
2953 pp_string (pp
, "__asm__");
2954 if (ASM_VOLATILE_P (node
))
2955 pp_string (pp
, " __volatile__");
2957 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2959 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2961 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2962 if (ASM_CLOBBERS (node
))
2965 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2967 pp_right_paren (pp
);
2970 case CASE_LABEL_EXPR
:
2971 if (CASE_LOW (node
) && CASE_HIGH (node
))
2973 pp_string (pp
, "case ");
2974 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2975 pp_string (pp
, " ... ");
2976 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2978 else if (CASE_LOW (node
))
2980 pp_string (pp
, "case ");
2981 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2984 pp_string (pp
, "default");
2989 pp_string (pp
, "OBJ_TYPE_REF(");
2990 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2992 /* We omit the class type for -fcompare-debug because we may
2993 drop TYPE_BINFO early depending on debug info, and then
2994 virtual_method_call_p would return false, whereas when
2995 TYPE_BINFO is preserved it may still return true and then
2996 we'd print the class type. Compare tree and rtl dumps for
2997 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
2998 for example, at occurrences of OBJ_TYPE_REF. */
2999 if (!(flags
& (TDF_SLIM
| TDF_COMPARE_DEBUG
))
3000 && virtual_method_call_p (node
))
3002 pp_string (pp
, "(");
3003 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
3004 pp_string (pp
, ")");
3006 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
3008 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
3009 pp_right_paren (pp
);
3013 if (SSA_NAME_IDENTIFIER (node
))
3015 if ((flags
& TDF_NOUID
)
3016 && SSA_NAME_VAR (node
)
3017 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
3018 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
3019 else if (! (flags
& TDF_GIMPLE
)
3020 || SSA_NAME_VAR (node
))
3021 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
3025 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
3026 if (SSA_NAME_IS_DEFAULT_DEF (node
))
3027 pp_string (pp
, "(D)");
3028 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
3029 pp_string (pp
, "(ab)");
3032 case WITH_SIZE_EXPR
:
3033 pp_string (pp
, "WITH_SIZE_EXPR <");
3034 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3035 pp_string (pp
, ", ");
3036 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3041 pp_string (pp
, "ASSERT_EXPR <");
3042 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
3043 pp_string (pp
, ", ");
3044 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
3049 pp_string (pp
, "scev_known");
3052 case SCEV_NOT_KNOWN
:
3053 pp_string (pp
, "scev_not_known");
3056 case POLYNOMIAL_CHREC
:
3058 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
3059 pp_string (pp
, ", +, ");
3060 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
3061 pp_printf (pp
, "}_%u", CHREC_VARIABLE (node
));
3065 case REALIGN_LOAD_EXPR
:
3066 pp_string (pp
, "REALIGN_LOAD <");
3067 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3068 pp_string (pp
, ", ");
3069 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3070 pp_string (pp
, ", ");
3071 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3076 pp_string (pp
, " VEC_COND_EXPR < ");
3077 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3078 pp_string (pp
, " , ");
3079 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3080 pp_string (pp
, " , ");
3081 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3082 pp_string (pp
, " > ");
3086 pp_string (pp
, " VEC_PERM_EXPR < ");
3087 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3088 pp_string (pp
, " , ");
3089 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3090 pp_string (pp
, " , ");
3091 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3092 pp_string (pp
, " > ");
3096 pp_string (pp
, " DOT_PROD_EXPR < ");
3097 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3098 pp_string (pp
, ", ");
3099 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3100 pp_string (pp
, ", ");
3101 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3102 pp_string (pp
, " > ");
3105 case WIDEN_MULT_PLUS_EXPR
:
3106 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
3107 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3108 pp_string (pp
, ", ");
3109 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3110 pp_string (pp
, ", ");
3111 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3112 pp_string (pp
, " > ");
3115 case WIDEN_MULT_MINUS_EXPR
:
3116 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
3117 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3118 pp_string (pp
, ", ");
3119 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3120 pp_string (pp
, ", ");
3121 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3122 pp_string (pp
, " > ");
3126 pp_string (pp
, "#pragma acc parallel");
3127 goto dump_omp_clauses_body
;
3130 pp_string (pp
, "#pragma acc kernels");
3131 goto dump_omp_clauses_body
;
3134 pp_string (pp
, "#pragma acc data");
3135 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
3138 case OACC_HOST_DATA
:
3139 pp_string (pp
, "#pragma acc host_data");
3140 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
3144 pp_string (pp
, "#pragma acc declare");
3145 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
3149 pp_string (pp
, "#pragma acc update");
3150 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
3153 case OACC_ENTER_DATA
:
3154 pp_string (pp
, "#pragma acc enter data");
3155 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3158 case OACC_EXIT_DATA
:
3159 pp_string (pp
, "#pragma acc exit data");
3160 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3164 pp_string (pp
, "#pragma acc cache");
3165 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
3169 pp_string (pp
, "#pragma omp parallel");
3170 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
3173 dump_omp_clauses_body
:
3174 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
3178 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
3180 newline_and_indent (pp
, spc
+ 2);
3182 newline_and_indent (pp
, spc
+ 4);
3183 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
3184 newline_and_indent (pp
, spc
+ 2);
3185 pp_right_brace (pp
);
3191 pp_string (pp
, OMP_TASK_BODY (node
) ? "#pragma omp task"
3192 : "#pragma omp taskwait");
3193 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
3197 pp_string (pp
, "#pragma omp for");
3201 pp_string (pp
, "#pragma omp simd");
3204 case OMP_DISTRIBUTE
:
3205 pp_string (pp
, "#pragma omp distribute");
3209 pp_string (pp
, "#pragma omp taskloop");
3213 pp_string (pp
, "#pragma acc loop");
3217 pp_string (pp
, "#pragma omp teams");
3218 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
3221 case OMP_TARGET_DATA
:
3222 pp_string (pp
, "#pragma omp target data");
3223 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
3226 case OMP_TARGET_ENTER_DATA
:
3227 pp_string (pp
, "#pragma omp target enter data");
3228 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3232 case OMP_TARGET_EXIT_DATA
:
3233 pp_string (pp
, "#pragma omp target exit data");
3234 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3239 pp_string (pp
, "#pragma omp target");
3240 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3243 case OMP_TARGET_UPDATE
:
3244 pp_string (pp
, "#pragma omp target update");
3245 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3250 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3251 if (!(flags
& TDF_SLIM
))
3255 if (OMP_FOR_PRE_BODY (node
))
3257 newline_and_indent (pp
, spc
+ 2);
3260 newline_and_indent (pp
, spc
);
3261 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3264 if (OMP_FOR_INIT (node
))
3267 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3270 newline_and_indent (pp
, spc
);
3271 pp_string (pp
, "for (");
3272 dump_generic_node (pp
,
3273 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
3275 pp_string (pp
, "; ");
3276 dump_generic_node (pp
,
3277 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
3279 pp_string (pp
, "; ");
3280 dump_generic_node (pp
,
3281 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3283 pp_right_paren (pp
);
3286 if (OMP_FOR_BODY (node
))
3288 newline_and_indent (pp
, spc
+ 2);
3290 newline_and_indent (pp
, spc
+ 4);
3291 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3293 newline_and_indent (pp
, spc
+ 2);
3294 pp_right_brace (pp
);
3296 if (OMP_FOR_INIT (node
))
3297 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3298 if (OMP_FOR_PRE_BODY (node
))
3301 newline_and_indent (pp
, spc
+ 2);
3302 pp_right_brace (pp
);
3309 pp_string (pp
, "#pragma omp sections");
3310 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3314 pp_string (pp
, "#pragma omp section");
3318 if (OMP_SCAN_CLAUSES (node
))
3320 pp_string (pp
, "#pragma omp scan");
3321 dump_omp_clauses (pp
, OMP_SCAN_CLAUSES (node
), spc
, flags
);
3326 pp_string (pp
, "#pragma omp master");
3330 pp_string (pp
, "#pragma omp taskgroup");
3331 dump_omp_clauses (pp
, OMP_TASKGROUP_CLAUSES (node
), spc
, flags
);
3335 pp_string (pp
, "#pragma omp ordered");
3336 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3340 pp_string (pp
, "#pragma omp critical");
3341 if (OMP_CRITICAL_NAME (node
))
3345 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3347 pp_right_paren (pp
);
3349 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3353 pp_string (pp
, "#pragma omp atomic");
3354 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3355 newline_and_indent (pp
, spc
+ 2);
3356 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3360 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3363 case OMP_ATOMIC_READ
:
3364 pp_string (pp
, "#pragma omp atomic read");
3365 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3366 newline_and_indent (pp
, spc
+ 2);
3367 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3371 case OMP_ATOMIC_CAPTURE_OLD
:
3372 case OMP_ATOMIC_CAPTURE_NEW
:
3373 pp_string (pp
, "#pragma omp atomic capture");
3374 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3375 newline_and_indent (pp
, spc
+ 2);
3376 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3380 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3384 pp_string (pp
, "#pragma omp single");
3385 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3389 dump_omp_clause (pp
, node
, spc
, flags
);
3393 case TRANSACTION_EXPR
:
3394 if (TRANSACTION_EXPR_OUTER (node
))
3395 pp_string (pp
, "__transaction_atomic [[outer]]");
3396 else if (TRANSACTION_EXPR_RELAXED (node
))
3397 pp_string (pp
, "__transaction_relaxed");
3399 pp_string (pp
, "__transaction_atomic");
3400 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3402 newline_and_indent (pp
, spc
);
3404 newline_and_indent (pp
, spc
+ 2);
3405 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3406 spc
+ 2, flags
, false);
3407 newline_and_indent (pp
, spc
);
3408 pp_right_brace (pp
);
3413 case VEC_SERIES_EXPR
:
3414 case VEC_WIDEN_MULT_HI_EXPR
:
3415 case VEC_WIDEN_MULT_LO_EXPR
:
3416 case VEC_WIDEN_MULT_EVEN_EXPR
:
3417 case VEC_WIDEN_MULT_ODD_EXPR
:
3418 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3419 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3421 for (str
= get_tree_code_name (code
); *str
; str
++)
3422 pp_character (pp
, TOUPPER (*str
));
3423 pp_string (pp
, " < ");
3424 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3425 pp_string (pp
, ", ");
3426 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3427 pp_string (pp
, " > ");
3430 case VEC_DUPLICATE_EXPR
:
3432 for (str
= get_tree_code_name (code
); *str
; str
++)
3433 pp_character (pp
, TOUPPER (*str
));
3434 pp_string (pp
, " < ");
3435 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3436 pp_string (pp
, " > ");
3439 case VEC_UNPACK_HI_EXPR
:
3440 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3441 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3442 pp_string (pp
, " > ");
3445 case VEC_UNPACK_LO_EXPR
:
3446 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3447 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3448 pp_string (pp
, " > ");
3451 case VEC_UNPACK_FLOAT_HI_EXPR
:
3452 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3453 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3454 pp_string (pp
, " > ");
3457 case VEC_UNPACK_FLOAT_LO_EXPR
:
3458 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3459 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3460 pp_string (pp
, " > ");
3463 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3464 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
3465 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3466 pp_string (pp
, " > ");
3469 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3470 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
3471 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3472 pp_string (pp
, " > ");
3475 case VEC_PACK_TRUNC_EXPR
:
3476 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3477 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3478 pp_string (pp
, ", ");
3479 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3480 pp_string (pp
, " > ");
3483 case VEC_PACK_SAT_EXPR
:
3484 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3485 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3486 pp_string (pp
, ", ");
3487 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3488 pp_string (pp
, " > ");
3491 case VEC_PACK_FIX_TRUNC_EXPR
:
3492 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3493 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3494 pp_string (pp
, ", ");
3495 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3496 pp_string (pp
, " > ");
3499 case VEC_PACK_FLOAT_EXPR
:
3500 pp_string (pp
, " VEC_PACK_FLOAT_EXPR < ");
3501 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3502 pp_string (pp
, ", ");
3503 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3504 pp_string (pp
, " > ");
3508 dump_block_node (pp
, node
, spc
, flags
);
3511 case DEBUG_BEGIN_STMT
:
3512 pp_string (pp
, "# DEBUG BEGIN STMT");
3519 if (is_stmt
&& is_expr
)
3525 /* Print the declaration of a variable. */
3528 print_declaration (pretty_printer
*pp
, tree t
, int spc
, dump_flags_t flags
)
3532 if (TREE_CODE(t
) == NAMELIST_DECL
)
3534 pp_string(pp
, "namelist ");
3535 dump_decl_name (pp
, t
, flags
);
3540 if (TREE_CODE (t
) == TYPE_DECL
)
3541 pp_string (pp
, "typedef ");
3543 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3544 pp_string (pp
, "register ");
3546 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3547 pp_string (pp
, "extern ");
3548 else if (TREE_STATIC (t
))
3549 pp_string (pp
, "static ");
3551 /* Print the type and name. */
3552 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3556 /* Print array's type. */
3557 tmp
= TREE_TYPE (t
);
3558 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3559 tmp
= TREE_TYPE (tmp
);
3560 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3562 /* Print variable's name. */
3564 dump_generic_node (pp
, t
, spc
, flags
, false);
3566 /* Print the dimensions. */
3567 tmp
= TREE_TYPE (t
);
3568 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3570 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3571 tmp
= TREE_TYPE (tmp
);
3574 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3576 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3578 dump_decl_name (pp
, t
, flags
);
3579 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3583 /* Print type declaration. */
3584 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3586 /* Print variable's name. */
3588 dump_generic_node (pp
, t
, spc
, flags
, false);
3591 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
3593 pp_string (pp
, " __asm__ ");
3595 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3596 pp_right_paren (pp
);
3599 /* The initial value of a function serves to determine whether the function
3600 is declared or defined. So the following does not apply to function
3602 if (TREE_CODE (t
) != FUNCTION_DECL
)
3604 /* Print the initial value. */
3605 if (DECL_INITIAL (t
))
3610 if (!(flags
& TDF_SLIM
))
3611 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3613 pp_string (pp
, "<<< omitted >>>");
3617 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3619 pp_string (pp
, " [value-expr: ");
3620 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3621 pp_right_bracket (pp
);
3628 /* Prints a structure: name, fields, and methods.
3629 FIXME: Still incomplete. */
3632 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
3635 /* Print the name of the structure. */
3636 if (TYPE_NAME (node
))
3639 if (TREE_CODE (node
) == RECORD_TYPE
)
3640 pp_string (pp
, "struct ");
3641 else if ((TREE_CODE (node
) == UNION_TYPE
3642 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3643 pp_string (pp
, "union ");
3645 dump_generic_node (pp
, TYPE_NAME (node
), spc
, TDF_NONE
, false);
3648 /* Print the contents of the structure. */
3654 /* Print the fields of the structure. */
3657 tmp
= TYPE_FIELDS (node
);
3660 /* Avoid to print recursively the structure. */
3661 /* FIXME : Not implemented correctly...,
3662 what about the case when we have a cycle in the contain graph? ...
3663 Maybe this could be solved by looking at the scope in which the
3664 structure was declared. */
3665 if (TREE_TYPE (tmp
) != node
3666 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3667 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3669 print_declaration (pp
, tmp
, spc
+2, flags
);
3672 tmp
= DECL_CHAIN (tmp
);
3676 pp_right_brace (pp
);
3679 /* Return the priority of the operator CODE.
3681 From lowest to highest precedence with either left-to-right (L-R)
3682 or right-to-left (R-L) associativity]:
3685 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3697 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3698 15 [L-R] fn() [] -> .
3700 unary +, - and * have higher precedence than the corresponding binary
3704 op_code_prio (enum tree_code code
)
3721 case TRUTH_ORIF_EXPR
:
3724 case TRUTH_AND_EXPR
:
3725 case TRUTH_ANDIF_EXPR
:
3732 case TRUTH_XOR_EXPR
:
3749 case UNORDERED_EXPR
:
3760 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3761 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3762 case WIDEN_LSHIFT_EXPR
:
3765 case WIDEN_SUM_EXPR
:
3767 case POINTER_PLUS_EXPR
:
3768 case POINTER_DIFF_EXPR
:
3772 case VEC_WIDEN_MULT_HI_EXPR
:
3773 case VEC_WIDEN_MULT_LO_EXPR
:
3774 case WIDEN_MULT_EXPR
:
3776 case WIDEN_MULT_PLUS_EXPR
:
3777 case WIDEN_MULT_MINUS_EXPR
:
3779 case MULT_HIGHPART_EXPR
:
3780 case TRUNC_DIV_EXPR
:
3782 case FLOOR_DIV_EXPR
:
3783 case ROUND_DIV_EXPR
:
3785 case EXACT_DIV_EXPR
:
3786 case TRUNC_MOD_EXPR
:
3788 case FLOOR_MOD_EXPR
:
3789 case ROUND_MOD_EXPR
:
3792 case TRUTH_NOT_EXPR
:
3794 case POSTINCREMENT_EXPR
:
3795 case POSTDECREMENT_EXPR
:
3796 case PREINCREMENT_EXPR
:
3797 case PREDECREMENT_EXPR
:
3803 case FIX_TRUNC_EXPR
:
3809 case ARRAY_RANGE_REF
:
3813 /* Special expressions. */
3819 case VEC_UNPACK_HI_EXPR
:
3820 case VEC_UNPACK_LO_EXPR
:
3821 case VEC_UNPACK_FLOAT_HI_EXPR
:
3822 case VEC_UNPACK_FLOAT_LO_EXPR
:
3823 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3824 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3825 case VEC_PACK_TRUNC_EXPR
:
3826 case VEC_PACK_SAT_EXPR
:
3830 /* Return an arbitrarily high precedence to avoid surrounding single
3831 VAR_DECLs in ()s. */
3836 /* Return the priority of the operator OP. */
3839 op_prio (const_tree op
)
3841 enum tree_code code
;
3846 code
= TREE_CODE (op
);
3847 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3848 return op_prio (TREE_OPERAND (op
, 0));
3850 return op_code_prio (code
);
3853 /* Return the symbol associated with operator CODE. */
3856 op_symbol_code (enum tree_code code
)
3864 case TRUTH_ORIF_EXPR
:
3867 case TRUTH_AND_EXPR
:
3868 case TRUTH_ANDIF_EXPR
:
3874 case TRUTH_XOR_EXPR
:
3884 case UNORDERED_EXPR
:
3930 case WIDEN_LSHIFT_EXPR
:
3933 case POINTER_PLUS_EXPR
:
3939 case WIDEN_SUM_EXPR
:
3942 case WIDEN_MULT_EXPR
:
3945 case MULT_HIGHPART_EXPR
:
3950 case POINTER_DIFF_EXPR
:
3956 case TRUTH_NOT_EXPR
:
3963 case TRUNC_DIV_EXPR
:
3970 case FLOOR_DIV_EXPR
:
3973 case ROUND_DIV_EXPR
:
3976 case EXACT_DIV_EXPR
:
3979 case TRUNC_MOD_EXPR
:
3985 case FLOOR_MOD_EXPR
:
3988 case ROUND_MOD_EXPR
:
3991 case PREDECREMENT_EXPR
:
3994 case PREINCREMENT_EXPR
:
3997 case POSTDECREMENT_EXPR
:
4000 case POSTINCREMENT_EXPR
:
4010 return "<<< ??? >>>";
4014 /* Return the symbol associated with operator OP. */
4017 op_symbol (const_tree op
)
4019 return op_symbol_code (TREE_CODE (op
));
4022 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
4023 the gimple_call_fn of a GIMPLE_CALL. */
4026 print_call_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
4030 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
4031 op0
= TREE_OPERAND (op0
, 0);
4034 switch (TREE_CODE (op0
))
4039 dump_function_name (pp
, op0
, flags
);
4045 op0
= TREE_OPERAND (op0
, 0);
4050 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
4051 pp_string (pp
, ") ? ");
4052 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
4053 pp_string (pp
, " : ");
4054 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
4058 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
4059 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
4061 dump_generic_node (pp
, op0
, 0, flags
, false);
4065 if (integer_zerop (TREE_OPERAND (op0
, 1)))
4067 op0
= TREE_OPERAND (op0
, 0);
4074 dump_generic_node (pp
, op0
, 0, flags
, false);
4082 /* Print the first N characters in the array STR, replacing non-printable
4083 characters (including embedded nuls) with unambiguous escape sequences. */
4086 pretty_print_string (pretty_printer
*pp
, const char *str
, unsigned n
)
4091 for ( ; n
; --n
, ++str
)
4096 pp_string (pp
, "\\b");
4100 pp_string (pp
, "\\f");
4104 pp_string (pp
, "\\n");
4108 pp_string (pp
, "\\r");
4112 pp_string (pp
, "\\t");
4116 pp_string (pp
, "\\v");
4120 pp_string (pp
, "\\\\");
4124 pp_string (pp
, "\\\"");
4128 pp_string (pp
, "\\'");
4132 if (str
[0] || n
> 1)
4134 if (!ISPRINT (str
[0]))
4137 sprintf (buf
, "\\x%02x", (unsigned char)str
[0]);
4138 pp_string (pp
, buf
);
4141 pp_character (pp
, str
[0]);
4149 maybe_init_pretty_print (FILE *file
)
4153 tree_pp
= new pretty_printer ();
4154 pp_needs_newline (tree_pp
) = true;
4155 pp_translate_identifiers (tree_pp
) = false;
4158 tree_pp
->buffer
->stream
= file
;
4162 newline_and_indent (pretty_printer
*pp
, int spc
)
4168 /* Handle the %K format for TEXT. Separate from default_tree_printer
4169 so it can also be used in front ends.
4170 The location LOC and BLOCK are expected to be extracted by the caller
4171 from the %K argument arg via EXPR_LOCATION(arg) and TREE_BLOCK(arg). */
4174 percent_K_format (text_info
*text
, location_t loc
, tree block
)
4176 text
->set_location (0, loc
, SHOW_RANGE_WITH_CARET
);
4177 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
4178 *pp_ti_abstract_origin (text
) = NULL
;
4181 && TREE_CODE (block
) == BLOCK
4182 && BLOCK_ABSTRACT_ORIGIN (block
))
4184 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
4185 if (TREE_CODE (ao
) == FUNCTION_DECL
)
4187 *pp_ti_abstract_origin (text
) = block
;
4190 block
= BLOCK_SUPERCONTEXT (block
);
4194 /* Print the identifier ID to PRETTY-PRINTER. */
4197 pp_tree_identifier (pretty_printer
*pp
, tree id
)
4199 if (pp_translate_identifiers (pp
))
4201 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
4202 pp_append_text (pp
, text
, text
+ strlen (text
));
4205 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
4206 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
4209 /* A helper function that is used to dump function information before the
4213 dump_function_header (FILE *dump_file
, tree fdecl
, dump_flags_t flags
)
4215 const char *dname
, *aname
;
4216 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
4217 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
4219 dname
= lang_hooks
.decl_printable_name (fdecl
, 1);
4221 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
4222 aname
= (IDENTIFIER_POINTER
4223 (DECL_ASSEMBLER_NAME (fdecl
)));
4225 aname
= "<unset-asm-name>";
4227 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
4228 dname
, aname
, fun
->funcdef_no
);
4229 if (!(flags
& TDF_NOUID
))
4230 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
4233 fprintf (dump_file
, ", cgraph_uid=%d", node
->get_uid ());
4234 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
4235 node
->frequency
== NODE_FREQUENCY_HOT
4237 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
4238 ? " (unlikely executed)"
4239 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
4240 ? " (executed once)"
4244 fprintf (dump_file
, ")\n\n");
4247 /* Dump double_int D to pretty_printer PP. UNS is true
4248 if D is unsigned and false otherwise. */
4250 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4253 pp_wide_integer (pp
, d
.low
);
4254 else if (d
.fits_uhwi ())
4255 pp_unsigned_wide_integer (pp
, d
.low
);
4258 unsigned HOST_WIDE_INT low
= d
.low
;
4259 HOST_WIDE_INT high
= d
.high
;
4260 if (!uns
&& d
.is_negative ())
4263 high
= ~high
+ !low
;
4266 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4268 sprintf (pp_buffer (pp
)->digit_buffer
,
4269 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4270 (unsigned HOST_WIDE_INT
) high
, low
);
4271 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
4276 # pragma GCC diagnostic pop