1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2020 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
29 #include "tree-pretty-print.h"
30 #include "stor-layout.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
34 #include "internal-fn.h"
35 #include "gomp-constants.h"
37 #include "fold-const.h"
39 /* Disable warnings about quoting issues in the pp_xxx calls below
40 that (intentionally) don't follow GCC diagnostic conventions. */
42 # pragma GCC diagnostic push
43 # pragma GCC diagnostic ignored "-Wformat-diag"
46 /* Local functions, macros and variables. */
47 static const char *op_symbol (const_tree
);
48 static void newline_and_indent (pretty_printer
*, int);
49 static void maybe_init_pretty_print (FILE *);
50 static void print_struct_decl (pretty_printer
*, const_tree
, int, dump_flags_t
);
51 static void do_niy (pretty_printer
*, const_tree
, dump_flags_t
);
53 #define INDENT(SPACE) do { \
54 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
56 #define NIY do_niy (pp, node, flags)
58 static pretty_printer
*tree_pp
;
60 /* Try to print something for an unknown tree code. */
63 do_niy (pretty_printer
*pp
, const_tree node
, dump_flags_t flags
)
67 pp_string (pp
, "<<< Unknown tree: ");
68 pp_string (pp
, get_tree_code_name (TREE_CODE (node
)));
72 len
= TREE_OPERAND_LENGTH (node
);
73 for (i
= 0; i
< len
; ++i
)
75 newline_and_indent (pp
, 2);
76 dump_generic_node (pp
, TREE_OPERAND (node
, i
), 2, flags
, false);
80 pp_string (pp
, " >>>");
83 /* Debugging function to print out a generic expression. */
86 debug_generic_expr (tree t
)
88 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
89 fprintf (stderr
, "\n");
92 /* Debugging function to print out a generic statement. */
95 debug_generic_stmt (tree t
)
97 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
98 fprintf (stderr
, "\n");
101 /* Debugging function to print out a chain of trees . */
104 debug_tree_chain (tree t
)
110 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
111 fprintf (stderr
, " ");
115 fprintf (stderr
, "... [cycled back to ");
116 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
117 fprintf (stderr
, "]");
121 fprintf (stderr
, "\n");
124 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
126 print_generic_decl (FILE *file
, tree decl
, dump_flags_t flags
)
128 maybe_init_pretty_print (file
);
129 print_declaration (tree_pp
, decl
, 2, flags
);
130 pp_write_text_to_stream (tree_pp
);
133 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
134 to show in the dump. See TDF_* in dumpfile.h. */
137 print_generic_stmt (FILE *file
, tree t
, dump_flags_t flags
)
139 maybe_init_pretty_print (file
);
140 dump_generic_node (tree_pp
, t
, 0, flags
, true);
141 pp_newline_and_flush (tree_pp
);
144 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
145 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
149 print_generic_stmt_indented (FILE *file
, tree t
, dump_flags_t flags
, int indent
)
153 maybe_init_pretty_print (file
);
155 for (i
= 0; i
< indent
; i
++)
157 dump_generic_node (tree_pp
, t
, indent
, flags
, true);
158 pp_newline_and_flush (tree_pp
);
161 /* Print a single expression T on file FILE. FLAGS specifies details to show
162 in the dump. See TDF_* in dumpfile.h. */
165 print_generic_expr (FILE *file
, tree t
, dump_flags_t flags
)
167 maybe_init_pretty_print (file
);
168 dump_generic_node (tree_pp
, t
, 0, flags
, false);
172 /* Print a single expression T to string, and return it. */
175 print_generic_expr_to_str (tree t
)
178 dump_generic_node (&pp
, t
, 0, TDF_VOPS
|TDF_MEMSYMS
, false);
179 return xstrdup (pp_formatted_text (&pp
));
182 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
183 in it are replaced with Dxxxx, as long as they are at the start or
184 preceded by $ and at the end or followed by $. See make_fancy_name
188 dump_fancy_name (pretty_printer
*pp
, tree name
)
191 int length
= IDENTIFIER_LENGTH (name
);
192 const char *n
= IDENTIFIER_POINTER (name
);
199 && (n
== IDENTIFIER_POINTER (name
) || n
[-1] == '$'))
202 while (ISDIGIT (n
[l
]))
204 if (n
[l
] == '\0' || n
[l
] == '$')
217 pp_tree_identifier (pp
, name
);
221 char *str
= XNEWVEC (char, length
+ 1);
224 q
= n
= IDENTIFIER_POINTER (name
);
231 && (q
== IDENTIFIER_POINTER (name
) || q
[-1] == '$'))
234 while (ISDIGIT (q
[l
]))
236 if (q
[l
] == '\0' || q
[l
] == '$')
238 memcpy (p
, n
, q
- n
);
239 memcpy (p
+ (q
- n
), "Dxxxx", 5);
249 memcpy (p
, n
, IDENTIFIER_LENGTH (name
) - (n
- IDENTIFIER_POINTER (name
)));
251 if (pp_translate_identifiers (pp
))
253 const char *text
= identifier_to_locale (str
);
254 pp_append_text (pp
, text
, text
+ strlen (text
));
257 pp_append_text (pp
, str
, str
+ length
);
261 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
265 dump_decl_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
267 tree name
= DECL_NAME (node
);
270 if ((flags
& TDF_ASMNAME
)
271 && HAS_DECL_ASSEMBLER_NAME_P (node
)
272 && DECL_ASSEMBLER_NAME_SET_P (node
))
273 pp_tree_identifier (pp
, DECL_ASSEMBLER_NAME_RAW (node
));
274 /* For -fcompare-debug don't dump DECL_NAMELESS names at all,
275 -g might have created more fancy names and their indexes
276 could get out of sync. Usually those should be DECL_IGNORED_P
277 too, SRA can create even non-DECL_IGNORED_P DECL_NAMELESS fancy
278 names, let's hope those never get out of sync after doing the
279 dump_fancy_name sanitization. */
280 else if ((flags
& TDF_COMPARE_DEBUG
)
281 && DECL_NAMELESS (node
)
282 && DECL_IGNORED_P (node
))
284 /* For DECL_NAMELESS names look for embedded uids in the
285 names and sanitize them for TDF_NOUID. */
286 else if ((flags
& TDF_NOUID
) && DECL_NAMELESS (node
))
287 dump_fancy_name (pp
, name
);
289 pp_tree_identifier (pp
, name
);
291 char uid_sep
= (flags
& TDF_GIMPLE
) ? '_' : '.';
292 if ((flags
& TDF_UID
) || name
== NULL_TREE
)
294 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
295 pp_printf (pp
, "L%c%d", uid_sep
, (int) LABEL_DECL_UID (node
));
296 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
298 if (flags
& TDF_NOUID
)
299 pp_string (pp
, "D#xxxx");
301 pp_printf (pp
, "D#%i", DEBUG_TEMP_UID (node
));
305 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
306 if (flags
& TDF_NOUID
)
307 pp_printf (pp
, "%c.xxxx", c
);
309 pp_printf (pp
, "%c%c%u", c
, uid_sep
, DECL_UID (node
));
312 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
314 if (flags
& TDF_NOUID
)
315 pp_printf (pp
, "ptD.xxxx");
317 pp_printf (pp
, "ptD.%u", DECL_PT_UID (node
));
321 /* Like the above, but used for pretty printing function calls. */
324 dump_function_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
326 if (CONVERT_EXPR_P (node
))
327 node
= TREE_OPERAND (node
, 0);
328 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
329 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
331 dump_decl_name (pp
, node
, flags
);
334 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
335 FLAGS are as in dump_generic_node. */
338 dump_function_declaration (pretty_printer
*pp
, tree node
,
339 int spc
, dump_flags_t flags
)
341 bool wrote_arg
= false;
347 /* Print the argument types. */
348 arg
= TYPE_ARG_TYPES (node
);
349 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
357 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
358 arg
= TREE_CHAIN (arg
);
361 /* Drop the trailing void_type_node if we had any previous argument. */
362 if (arg
== void_list_node
&& !wrote_arg
)
363 pp_string (pp
, "void");
364 /* Properly dump vararg function types. */
365 else if (!arg
&& wrote_arg
)
366 pp_string (pp
, ", ...");
367 /* Avoid printing any arg for unprototyped functions. */
372 /* Dump the domain associated with an array. */
375 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, dump_flags_t flags
)
377 pp_left_bracket (pp
);
380 tree min
= TYPE_MIN_VALUE (domain
);
381 tree max
= TYPE_MAX_VALUE (domain
);
384 && integer_zerop (min
)
385 && tree_fits_shwi_p (max
))
386 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
390 dump_generic_node (pp
, min
, spc
, flags
, false);
393 dump_generic_node (pp
, max
, spc
, flags
, false);
397 pp_string (pp
, "<unknown>");
398 pp_right_bracket (pp
);
402 /* Dump OpenMP iterators ITER. */
405 dump_omp_iterators (pretty_printer
*pp
, tree iter
, int spc
, dump_flags_t flags
)
407 pp_string (pp
, "iterator(");
408 for (tree it
= iter
; it
; it
= TREE_CHAIN (it
))
411 pp_string (pp
, ", ");
412 dump_generic_node (pp
, TREE_TYPE (TREE_VEC_ELT (it
, 0)), spc
, flags
,
415 dump_generic_node (pp
, TREE_VEC_ELT (it
, 0), spc
, flags
, false);
417 dump_generic_node (pp
, TREE_VEC_ELT (it
, 1), spc
, flags
, false);
419 dump_generic_node (pp
, TREE_VEC_ELT (it
, 2), spc
, flags
, false);
421 dump_generic_node (pp
, TREE_VEC_ELT (it
, 3), spc
, flags
, false);
427 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
428 dump_generic_node. */
431 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
434 const char *modifier
= NULL
;
435 switch (OMP_CLAUSE_CODE (clause
))
437 case OMP_CLAUSE_PRIVATE
:
440 case OMP_CLAUSE_SHARED
:
443 case OMP_CLAUSE_FIRSTPRIVATE
:
444 name
= "firstprivate";
446 case OMP_CLAUSE_LASTPRIVATE
:
447 name
= "lastprivate";
448 if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clause
))
449 modifier
= "conditional:";
451 case OMP_CLAUSE_COPYIN
:
454 case OMP_CLAUSE_COPYPRIVATE
:
455 name
= "copyprivate";
457 case OMP_CLAUSE_UNIFORM
:
460 case OMP_CLAUSE_USE_DEVICE_PTR
:
461 name
= "use_device_ptr";
462 if (OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT (clause
))
463 modifier
= "if_present:";
465 case OMP_CLAUSE_USE_DEVICE_ADDR
:
466 name
= "use_device_addr";
468 case OMP_CLAUSE_IS_DEVICE_PTR
:
469 name
= "is_device_ptr";
471 case OMP_CLAUSE_INCLUSIVE
:
474 case OMP_CLAUSE_EXCLUSIVE
:
477 case OMP_CLAUSE__LOOPTEMP_
:
480 case OMP_CLAUSE__REDUCTEMP_
:
481 name
= "_reductemp_";
483 case OMP_CLAUSE__CONDTEMP_
:
486 case OMP_CLAUSE__SCANTEMP_
:
489 case OMP_CLAUSE_TO_DECLARE
:
492 case OMP_CLAUSE_LINK
:
495 case OMP_CLAUSE_NONTEMPORAL
:
496 name
= "nontemporal";
499 pp_string (pp
, name
);
502 pp_string (pp
, modifier
);
503 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
508 case OMP_CLAUSE_TASK_REDUCTION
:
509 case OMP_CLAUSE_IN_REDUCTION
:
510 pp_string (pp
, OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_IN_REDUCTION
513 case OMP_CLAUSE_REDUCTION
:
514 pp_string (pp
, "reduction(");
515 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_REDUCTION
)
517 if (OMP_CLAUSE_REDUCTION_TASK (clause
))
518 pp_string (pp
, "task,");
519 else if (OMP_CLAUSE_REDUCTION_INSCAN (clause
))
520 pp_string (pp
, "inscan,");
522 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
525 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
528 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
534 pp_string (pp
, "if(");
535 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
537 case ERROR_MARK
: break;
538 case VOID_CST
: pp_string (pp
, "cancel:"); break;
539 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
540 case OMP_SIMD
: pp_string (pp
, "simd:"); break;
541 case OMP_TASK
: pp_string (pp
, "task:"); break;
542 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
543 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
544 case OMP_TARGET
: pp_string (pp
, "target:"); break;
545 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
546 case OMP_TARGET_ENTER_DATA
:
547 pp_string (pp
, "target enter data:"); break;
548 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
549 default: gcc_unreachable ();
551 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
556 case OMP_CLAUSE_NUM_THREADS
:
557 pp_string (pp
, "num_threads(");
558 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
563 case OMP_CLAUSE_NOWAIT
:
564 pp_string (pp
, "nowait");
566 case OMP_CLAUSE_ORDERED
:
567 pp_string (pp
, "ordered");
568 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
571 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
577 case OMP_CLAUSE_DEFAULT
:
578 pp_string (pp
, "default(");
579 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
581 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
583 case OMP_CLAUSE_DEFAULT_SHARED
:
584 pp_string (pp
, "shared");
586 case OMP_CLAUSE_DEFAULT_NONE
:
587 pp_string (pp
, "none");
589 case OMP_CLAUSE_DEFAULT_PRIVATE
:
590 pp_string (pp
, "private");
592 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
593 pp_string (pp
, "firstprivate");
595 case OMP_CLAUSE_DEFAULT_PRESENT
:
596 pp_string (pp
, "present");
604 case OMP_CLAUSE_SCHEDULE
:
605 pp_string (pp
, "schedule(");
606 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
607 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
608 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
610 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
611 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
612 pp_string (pp
, "monotonic");
614 pp_string (pp
, "nonmonotonic");
615 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
620 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
621 pp_string (pp
, "simd:");
623 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
625 case OMP_CLAUSE_SCHEDULE_STATIC
:
626 pp_string (pp
, "static");
628 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
629 pp_string (pp
, "dynamic");
631 case OMP_CLAUSE_SCHEDULE_GUIDED
:
632 pp_string (pp
, "guided");
634 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
635 pp_string (pp
, "runtime");
637 case OMP_CLAUSE_SCHEDULE_AUTO
:
638 pp_string (pp
, "auto");
643 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
646 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
652 case OMP_CLAUSE_UNTIED
:
653 pp_string (pp
, "untied");
656 case OMP_CLAUSE_COLLAPSE
:
657 pp_string (pp
, "collapse(");
658 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
663 case OMP_CLAUSE_FINAL
:
664 pp_string (pp
, "final(");
665 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
670 case OMP_CLAUSE_MERGEABLE
:
671 pp_string (pp
, "mergeable");
674 case OMP_CLAUSE_LINEAR
:
675 pp_string (pp
, "linear(");
676 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
678 case OMP_CLAUSE_LINEAR_DEFAULT
:
680 case OMP_CLAUSE_LINEAR_REF
:
681 pp_string (pp
, "ref(");
683 case OMP_CLAUSE_LINEAR_VAL
:
684 pp_string (pp
, "val(");
686 case OMP_CLAUSE_LINEAR_UVAL
:
687 pp_string (pp
, "uval(");
692 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
694 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
697 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
702 case OMP_CLAUSE_ALIGNED
:
703 pp_string (pp
, "aligned(");
704 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
706 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
709 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
715 case OMP_CLAUSE_DEPEND
:
716 pp_string (pp
, "depend(");
717 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
719 case OMP_CLAUSE_DEPEND_DEPOBJ
:
722 case OMP_CLAUSE_DEPEND_IN
:
725 case OMP_CLAUSE_DEPEND_OUT
:
728 case OMP_CLAUSE_DEPEND_INOUT
:
731 case OMP_CLAUSE_DEPEND_MUTEXINOUTSET
:
732 name
= "mutexinoutset";
734 case OMP_CLAUSE_DEPEND_SOURCE
:
735 pp_string (pp
, "source)");
737 case OMP_CLAUSE_DEPEND_LAST
:
738 name
= "__internal__";
740 case OMP_CLAUSE_DEPEND_SINK
:
741 pp_string (pp
, "sink:");
742 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
743 if (TREE_CODE (t
) == TREE_LIST
)
745 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
746 if (TREE_PURPOSE (t
) != integer_zero_node
)
748 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
752 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
766 tree t
= OMP_CLAUSE_DECL (clause
);
767 if (TREE_CODE (t
) == TREE_LIST
769 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
771 dump_omp_iterators (pp
, TREE_PURPOSE (t
), spc
, flags
);
775 pp_string (pp
, name
);
777 dump_generic_node (pp
, t
, spc
, flags
, false);
783 pp_string (pp
, "map(");
784 switch (OMP_CLAUSE_MAP_KIND (clause
))
787 case GOMP_MAP_POINTER
:
788 pp_string (pp
, "alloc");
790 case GOMP_MAP_IF_PRESENT
:
791 pp_string (pp
, "no_alloc");
794 case GOMP_MAP_TO_PSET
:
795 pp_string (pp
, "to");
798 pp_string (pp
, "from");
800 case GOMP_MAP_TOFROM
:
801 pp_string (pp
, "tofrom");
803 case GOMP_MAP_FORCE_ALLOC
:
804 pp_string (pp
, "force_alloc");
806 case GOMP_MAP_FORCE_TO
:
807 pp_string (pp
, "force_to");
809 case GOMP_MAP_FORCE_FROM
:
810 pp_string (pp
, "force_from");
812 case GOMP_MAP_FORCE_TOFROM
:
813 pp_string (pp
, "force_tofrom");
815 case GOMP_MAP_FORCE_PRESENT
:
816 pp_string (pp
, "force_present");
818 case GOMP_MAP_DELETE
:
819 pp_string (pp
, "delete");
821 case GOMP_MAP_FORCE_DEVICEPTR
:
822 pp_string (pp
, "force_deviceptr");
824 case GOMP_MAP_ALWAYS_TO
:
825 pp_string (pp
, "always,to");
827 case GOMP_MAP_ALWAYS_FROM
:
828 pp_string (pp
, "always,from");
830 case GOMP_MAP_ALWAYS_TOFROM
:
831 pp_string (pp
, "always,tofrom");
833 case GOMP_MAP_RELEASE
:
834 pp_string (pp
, "release");
836 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
837 pp_string (pp
, "firstprivate");
839 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
840 pp_string (pp
, "firstprivate ref");
842 case GOMP_MAP_STRUCT
:
843 pp_string (pp
, "struct");
845 case GOMP_MAP_ALWAYS_POINTER
:
846 pp_string (pp
, "always_pointer");
848 case GOMP_MAP_DEVICE_RESIDENT
:
849 pp_string (pp
, "device_resident");
852 pp_string (pp
, "link");
854 case GOMP_MAP_ATTACH
:
855 pp_string (pp
, "attach");
857 case GOMP_MAP_DETACH
:
858 pp_string (pp
, "detach");
860 case GOMP_MAP_FORCE_DETACH
:
861 pp_string (pp
, "force_detach");
863 case GOMP_MAP_ATTACH_DETACH
:
864 pp_string (pp
, "attach_detach");
870 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
873 if (OMP_CLAUSE_SIZE (clause
))
875 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
876 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
878 case GOMP_MAP_POINTER
:
879 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
880 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
881 case GOMP_MAP_ALWAYS_POINTER
:
882 pp_string (pp
, " [pointer assign, bias: ");
884 case GOMP_MAP_TO_PSET
:
885 pp_string (pp
, " [pointer set, len: ");
887 case GOMP_MAP_ATTACH
:
888 case GOMP_MAP_DETACH
:
889 case GOMP_MAP_FORCE_DETACH
:
890 case GOMP_MAP_ATTACH_DETACH
:
891 pp_string (pp
, " [bias: ");
894 pp_string (pp
, " [len: ");
897 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
899 pp_right_bracket (pp
);
904 case OMP_CLAUSE_FROM
:
905 pp_string (pp
, "from(");
906 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
908 goto print_clause_size
;
911 pp_string (pp
, "to(");
912 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
914 goto print_clause_size
;
916 case OMP_CLAUSE__CACHE_
:
918 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
920 goto print_clause_size
;
922 case OMP_CLAUSE_NUM_TEAMS
:
923 pp_string (pp
, "num_teams(");
924 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
929 case OMP_CLAUSE_THREAD_LIMIT
:
930 pp_string (pp
, "thread_limit(");
931 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
936 case OMP_CLAUSE_DEVICE
:
937 pp_string (pp
, "device(");
938 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
943 case OMP_CLAUSE_DIST_SCHEDULE
:
944 pp_string (pp
, "dist_schedule(static");
945 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
948 dump_generic_node (pp
,
949 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
955 case OMP_CLAUSE_PROC_BIND
:
956 pp_string (pp
, "proc_bind(");
957 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
959 case OMP_CLAUSE_PROC_BIND_MASTER
:
960 pp_string (pp
, "master");
962 case OMP_CLAUSE_PROC_BIND_CLOSE
:
963 pp_string (pp
, "close");
965 case OMP_CLAUSE_PROC_BIND_SPREAD
:
966 pp_string (pp
, "spread");
974 case OMP_CLAUSE_DEVICE_TYPE
:
975 pp_string (pp
, "device_type(");
976 switch (OMP_CLAUSE_DEVICE_TYPE_KIND (clause
))
978 case OMP_CLAUSE_DEVICE_TYPE_HOST
:
979 pp_string (pp
, "host");
981 case OMP_CLAUSE_DEVICE_TYPE_NOHOST
:
982 pp_string (pp
, "nohost");
984 case OMP_CLAUSE_DEVICE_TYPE_ANY
:
985 pp_string (pp
, "any");
993 case OMP_CLAUSE_SAFELEN
:
994 pp_string (pp
, "safelen(");
995 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
1000 case OMP_CLAUSE_SIMDLEN
:
1001 pp_string (pp
, "simdlen(");
1002 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
1004 pp_right_paren (pp
);
1007 case OMP_CLAUSE_PRIORITY
:
1008 pp_string (pp
, "priority(");
1009 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
1011 pp_right_paren (pp
);
1014 case OMP_CLAUSE_GRAINSIZE
:
1015 pp_string (pp
, "grainsize(");
1016 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
1018 pp_right_paren (pp
);
1021 case OMP_CLAUSE_NUM_TASKS
:
1022 pp_string (pp
, "num_tasks(");
1023 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
1025 pp_right_paren (pp
);
1028 case OMP_CLAUSE_HINT
:
1029 pp_string (pp
, "hint(");
1030 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
1032 pp_right_paren (pp
);
1035 case OMP_CLAUSE_DEFAULTMAP
:
1036 pp_string (pp
, "defaultmap(");
1037 switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (clause
))
1039 case OMP_CLAUSE_DEFAULTMAP_ALLOC
:
1040 pp_string (pp
, "alloc");
1042 case OMP_CLAUSE_DEFAULTMAP_TO
:
1043 pp_string (pp
, "to");
1045 case OMP_CLAUSE_DEFAULTMAP_FROM
:
1046 pp_string (pp
, "from");
1048 case OMP_CLAUSE_DEFAULTMAP_TOFROM
:
1049 pp_string (pp
, "tofrom");
1051 case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE
:
1052 pp_string (pp
, "firstprivate");
1054 case OMP_CLAUSE_DEFAULTMAP_NONE
:
1055 pp_string (pp
, "none");
1057 case OMP_CLAUSE_DEFAULTMAP_DEFAULT
:
1058 pp_string (pp
, "default");
1063 switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (clause
))
1065 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED
:
1067 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR
:
1068 pp_string (pp
, ":scalar");
1070 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE
:
1071 pp_string (pp
, ":aggregate");
1073 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE
:
1074 pp_string (pp
, ":allocatable");
1076 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER
:
1077 pp_string (pp
, ":pointer");
1082 pp_right_paren (pp
);
1085 case OMP_CLAUSE_ORDER
:
1086 pp_string (pp
, "order(concurrent)");
1089 case OMP_CLAUSE_BIND
:
1090 pp_string (pp
, "bind(");
1091 switch (OMP_CLAUSE_BIND_KIND (clause
))
1093 case OMP_CLAUSE_BIND_TEAMS
:
1094 pp_string (pp
, "teams");
1096 case OMP_CLAUSE_BIND_PARALLEL
:
1097 pp_string (pp
, "parallel");
1099 case OMP_CLAUSE_BIND_THREAD
:
1100 pp_string (pp
, "thread");
1105 pp_right_paren (pp
);
1108 case OMP_CLAUSE__SIMDUID_
:
1109 pp_string (pp
, "_simduid_(");
1110 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
1112 pp_right_paren (pp
);
1115 case OMP_CLAUSE__SIMT_
:
1116 pp_string (pp
, "_simt_");
1119 case OMP_CLAUSE_GANG
:
1120 pp_string (pp
, "gang");
1121 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
1123 pp_string (pp
, "(num: ");
1124 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
1127 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
1129 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
1133 pp_string (pp
, "static:");
1134 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
1135 == integer_minus_one_node
)
1136 pp_character (pp
, '*');
1138 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
1141 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
1142 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
1143 pp_right_paren (pp
);
1146 case OMP_CLAUSE_ASYNC
:
1147 pp_string (pp
, "async");
1148 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
1150 pp_character(pp
, '(');
1151 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
1153 pp_character(pp
, ')');
1157 case OMP_CLAUSE_AUTO
:
1158 case OMP_CLAUSE_SEQ
:
1159 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
1162 case OMP_CLAUSE_WAIT
:
1163 pp_string (pp
, "wait(");
1164 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
1166 pp_character(pp
, ')');
1169 case OMP_CLAUSE_WORKER
:
1170 pp_string (pp
, "worker");
1171 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
1174 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
1176 pp_right_paren (pp
);
1180 case OMP_CLAUSE_VECTOR
:
1181 pp_string (pp
, "vector");
1182 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
1185 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
1187 pp_right_paren (pp
);
1191 case OMP_CLAUSE_NUM_GANGS
:
1192 pp_string (pp
, "num_gangs(");
1193 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
1195 pp_character (pp
, ')');
1198 case OMP_CLAUSE_NUM_WORKERS
:
1199 pp_string (pp
, "num_workers(");
1200 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
1202 pp_character (pp
, ')');
1205 case OMP_CLAUSE_VECTOR_LENGTH
:
1206 pp_string (pp
, "vector_length(");
1207 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
1209 pp_character (pp
, ')');
1212 case OMP_CLAUSE_INBRANCH
:
1213 pp_string (pp
, "inbranch");
1215 case OMP_CLAUSE_NOTINBRANCH
:
1216 pp_string (pp
, "notinbranch");
1218 case OMP_CLAUSE_FOR
:
1219 pp_string (pp
, "for");
1221 case OMP_CLAUSE_PARALLEL
:
1222 pp_string (pp
, "parallel");
1224 case OMP_CLAUSE_SECTIONS
:
1225 pp_string (pp
, "sections");
1227 case OMP_CLAUSE_TASKGROUP
:
1228 pp_string (pp
, "taskgroup");
1230 case OMP_CLAUSE_NOGROUP
:
1231 pp_string (pp
, "nogroup");
1233 case OMP_CLAUSE_THREADS
:
1234 pp_string (pp
, "threads");
1236 case OMP_CLAUSE_SIMD
:
1237 pp_string (pp
, "simd");
1239 case OMP_CLAUSE_INDEPENDENT
:
1240 pp_string (pp
, "independent");
1242 case OMP_CLAUSE_TILE
:
1243 pp_string (pp
, "tile(");
1244 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1246 pp_right_paren (pp
);
1249 case OMP_CLAUSE__GRIDDIM_
:
1250 pp_string (pp
, "_griddim_(");
1251 pp_unsigned_wide_integer (pp
, OMP_CLAUSE__GRIDDIM__DIMENSION (clause
));
1253 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__SIZE (clause
), spc
, flags
,
1256 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__GROUP (clause
), spc
, flags
,
1258 pp_right_paren (pp
);
1260 case OMP_CLAUSE_IF_PRESENT
:
1261 pp_string (pp
, "if_present");
1263 case OMP_CLAUSE_FINALIZE
:
1264 pp_string (pp
, "finalize");
1273 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1274 dump_generic_node. */
1277 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
1285 dump_omp_clause (pp
, clause
, spc
, flags
);
1286 clause
= OMP_CLAUSE_CHAIN (clause
);
1294 /* Dump location LOC to PP. */
1297 dump_location (pretty_printer
*pp
, location_t loc
)
1299 expanded_location xloc
= expand_location (loc
);
1301 pp_left_bracket (pp
);
1304 pp_string (pp
, xloc
.file
);
1305 pp_string (pp
, ":");
1307 pp_decimal_int (pp
, xloc
.line
);
1309 pp_decimal_int (pp
, xloc
.column
);
1310 pp_string (pp
, "] ");
1314 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1315 dump_generic_node. */
1318 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, dump_flags_t flags
)
1322 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1324 if (flags
& TDF_ADDRESS
)
1325 pp_printf (pp
, "[%p] ", (void *) block
);
1327 if (TREE_ASM_WRITTEN (block
))
1328 pp_string (pp
, "[written] ");
1330 if (flags
& TDF_SLIM
)
1333 if (BLOCK_SOURCE_LOCATION (block
))
1334 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1336 newline_and_indent (pp
, spc
+ 2);
1338 if (BLOCK_SUPERCONTEXT (block
))
1340 pp_string (pp
, "SUPERCONTEXT: ");
1341 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1342 flags
| TDF_SLIM
, false);
1343 newline_and_indent (pp
, spc
+ 2);
1346 if (BLOCK_SUBBLOCKS (block
))
1348 pp_string (pp
, "SUBBLOCKS: ");
1349 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1351 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1354 newline_and_indent (pp
, spc
+ 2);
1357 if (BLOCK_CHAIN (block
))
1359 pp_string (pp
, "SIBLINGS: ");
1360 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1362 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1365 newline_and_indent (pp
, spc
+ 2);
1368 if (BLOCK_VARS (block
))
1370 pp_string (pp
, "VARS: ");
1371 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1373 dump_generic_node (pp
, t
, 0, flags
, false);
1376 newline_and_indent (pp
, spc
+ 2);
1379 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1382 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1384 pp_string (pp
, "NONLOCALIZED_VARS: ");
1385 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1387 dump_generic_node (pp
, t
, 0, flags
, false);
1390 newline_and_indent (pp
, spc
+ 2);
1393 if (BLOCK_ABSTRACT_ORIGIN (block
))
1395 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1396 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1397 flags
| TDF_SLIM
, false);
1398 newline_and_indent (pp
, spc
+ 2);
1401 if (BLOCK_FRAGMENT_ORIGIN (block
))
1403 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1404 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1405 flags
| TDF_SLIM
, false);
1406 newline_and_indent (pp
, spc
+ 2);
1409 if (BLOCK_FRAGMENT_CHAIN (block
))
1411 pp_string (pp
, "FRAGMENT_CHAIN: ");
1412 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1414 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1417 newline_and_indent (pp
, spc
+ 2);
1421 /* Dump #pragma omp atomic memory order clause. */
1424 dump_omp_atomic_memory_order (pretty_printer
*pp
, enum omp_memory_order mo
)
1428 case OMP_MEMORY_ORDER_RELAXED
:
1429 pp_string (pp
, " relaxed");
1431 case OMP_MEMORY_ORDER_SEQ_CST
:
1432 pp_string (pp
, " seq_cst");
1434 case OMP_MEMORY_ORDER_ACQ_REL
:
1435 pp_string (pp
, " acq_rel");
1437 case OMP_MEMORY_ORDER_ACQUIRE
:
1438 pp_string (pp
, " acquire");
1440 case OMP_MEMORY_ORDER_RELEASE
:
1441 pp_string (pp
, " release");
1443 case OMP_MEMORY_ORDER_UNSPECIFIED
:
1450 /* Helper to dump a MEM_REF node. */
1453 dump_mem_ref (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
)
1455 if (flags
& TDF_GIMPLE
)
1457 pp_string (pp
, "__MEM <");
1458 dump_generic_node (pp
, TREE_TYPE (node
),
1459 spc
, flags
| TDF_SLIM
, false);
1460 if (TYPE_ALIGN (TREE_TYPE (node
))
1461 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
1463 pp_string (pp
, ", ");
1464 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
1467 pp_string (pp
, " (");
1468 if (TREE_TYPE (TREE_OPERAND (node
, 0))
1469 != TREE_TYPE (TREE_OPERAND (node
, 1)))
1472 dump_generic_node (pp
, TREE_TYPE (TREE_OPERAND (node
, 1)),
1473 spc
, flags
| TDF_SLIM
, false);
1474 pp_right_paren (pp
);
1476 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1477 spc
, flags
| TDF_SLIM
, false);
1478 if (! integer_zerop (TREE_OPERAND (node
, 1)))
1480 pp_string (pp
, " + ");
1481 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1482 spc
, flags
| TDF_SLIM
, false);
1484 pp_right_paren (pp
);
1486 else if (integer_zerop (TREE_OPERAND (node
, 1))
1487 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1488 infer them and MEM_ATTR caching will share MEM_REFs
1489 with differently-typed op0s. */
1490 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1491 /* Released SSA_NAMES have no TREE_TYPE. */
1492 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1493 /* Same pointer types, but ignoring POINTER_TYPE vs.
1495 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1496 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1497 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1498 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1499 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1500 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1501 /* Same value types ignoring qualifiers. */
1502 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1503 == TYPE_MAIN_VARIANT
1504 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1505 && (!(flags
& TDF_ALIAS
)
1506 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1508 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1510 /* Enclose pointers to arrays in parentheses. */
1511 tree op0
= TREE_OPERAND (node
, 0);
1512 tree op0type
= TREE_TYPE (op0
);
1513 if (POINTER_TYPE_P (op0type
)
1514 && TREE_CODE (TREE_TYPE (op0type
)) == ARRAY_TYPE
)
1517 dump_generic_node (pp
, op0
, spc
, flags
, false);
1518 if (POINTER_TYPE_P (op0type
)
1519 && TREE_CODE (TREE_TYPE (op0type
)) == ARRAY_TYPE
)
1520 pp_right_paren (pp
);
1523 dump_generic_node (pp
,
1524 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1529 pp_string (pp
, "MEM");
1531 tree nodetype
= TREE_TYPE (node
);
1532 tree op0
= TREE_OPERAND (node
, 0);
1533 tree op1
= TREE_OPERAND (node
, 1);
1534 tree op1type
= TYPE_MAIN_VARIANT (TREE_TYPE (op1
));
1536 tree op0size
= TYPE_SIZE (nodetype
);
1537 tree op1size
= TYPE_SIZE (TREE_TYPE (op1type
));
1539 if (!op0size
|| !op1size
1540 || !operand_equal_p (op0size
, op1size
, 0))
1542 pp_string (pp
, " <");
1543 /* If the size of the type of the operand is not the same
1544 as the size of the MEM_REF expression include the type
1545 of the latter similar to the TDF_GIMPLE output to make
1546 it clear how many bytes of memory are being accessed. */
1547 dump_generic_node (pp
, nodetype
, spc
, flags
| TDF_SLIM
, false);
1548 pp_string (pp
, "> ");
1551 pp_string (pp
, "[(");
1552 dump_generic_node (pp
, op1type
, spc
, flags
| TDF_SLIM
, false);
1553 pp_right_paren (pp
);
1554 dump_generic_node (pp
, op0
, spc
, flags
, false);
1555 if (!integer_zerop (op1
))
1556 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1558 pp_string (pp
, " + ");
1559 dump_generic_node (pp
, op1
, spc
, flags
, false);
1561 if ((flags
& TDF_ALIAS
)
1562 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1564 pp_string (pp
, " clique ");
1565 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1566 pp_string (pp
, " base ");
1567 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1569 pp_right_bracket (pp
);
1573 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1574 indent. FLAGS specifies details to show in the dump (see TDF_* in
1575 dumpfile.h). If IS_STMT is true, the object printed is considered
1576 to be a statement and it is terminated by ';' if appropriate. */
1579 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
,
1586 enum tree_code code
;
1588 if (node
== NULL_TREE
)
1591 is_expr
= EXPR_P (node
);
1593 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1594 pp_printf (pp
, "<&%p> ", (void *)node
);
1596 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1597 dump_location (pp
, EXPR_LOCATION (node
));
1599 code
= TREE_CODE (node
);
1603 pp_string (pp
, "<<< error >>>");
1606 case IDENTIFIER_NODE
:
1607 pp_tree_identifier (pp
, node
);
1611 while (node
&& node
!= error_mark_node
)
1613 if (TREE_PURPOSE (node
))
1615 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1618 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1619 node
= TREE_CHAIN (node
);
1620 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1629 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1635 if (TREE_VEC_LENGTH (node
) > 0)
1637 size_t len
= TREE_VEC_LENGTH (node
);
1638 for (i
= 0; i
< len
- 1; i
++)
1640 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1645 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1654 case FIXED_POINT_TYPE
:
1660 unsigned int quals
= TYPE_QUALS (node
);
1661 enum tree_code_class tclass
;
1663 if (quals
& TYPE_QUAL_ATOMIC
)
1664 pp_string (pp
, "atomic ");
1665 if (quals
& TYPE_QUAL_CONST
)
1666 pp_string (pp
, "const ");
1667 else if (quals
& TYPE_QUAL_VOLATILE
)
1668 pp_string (pp
, "volatile ");
1669 else if (quals
& TYPE_QUAL_RESTRICT
)
1670 pp_string (pp
, "restrict ");
1672 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1674 pp_string (pp
, "<address-space-");
1675 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1676 pp_string (pp
, "> ");
1679 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1681 if (tclass
== tcc_declaration
)
1683 if (DECL_NAME (node
))
1684 dump_decl_name (pp
, node
, flags
);
1686 pp_string (pp
, "<unnamed type decl>");
1688 else if (tclass
== tcc_type
)
1690 if (TYPE_NAME (node
))
1692 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1693 pp_tree_identifier (pp
, TYPE_NAME (node
));
1694 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1695 && DECL_NAME (TYPE_NAME (node
)))
1696 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1698 pp_string (pp
, "<unnamed type>");
1700 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1702 pp_string (pp
, "vector");
1704 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1705 pp_string (pp
, ") ");
1706 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1708 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1710 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1711 pp_string (pp
, (TYPE_UNSIGNED (node
)
1714 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1715 pp_string (pp
, (TYPE_UNSIGNED (node
)
1718 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1719 pp_string (pp
, (TYPE_UNSIGNED (node
)
1722 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1723 pp_string (pp
, (TYPE_UNSIGNED (node
)
1726 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1727 pp_string (pp
, (TYPE_UNSIGNED (node
)
1728 ? "unsigned long long"
1729 : "signed long long"));
1730 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1731 && pow2p_hwi (TYPE_PRECISION (node
)))
1733 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1734 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1735 pp_string (pp
, "_t");
1739 pp_string (pp
, (TYPE_UNSIGNED (node
)
1740 ? "<unnamed-unsigned:"
1741 : "<unnamed-signed:"));
1742 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1746 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1748 pp_string (pp
, "__complex__ ");
1749 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1751 else if (TREE_CODE (node
) == REAL_TYPE
)
1753 pp_string (pp
, "<float:");
1754 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1757 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1759 pp_string (pp
, "<fixed-point-");
1760 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1761 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1764 else if (TREE_CODE (node
) == BOOLEAN_TYPE
)
1766 pp_string (pp
, (TYPE_UNSIGNED (node
)
1767 ? "<unsigned-boolean:"
1768 : "<signed-boolean:"));
1769 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1772 else if (TREE_CODE (node
) == VOID_TYPE
)
1773 pp_string (pp
, "void");
1775 pp_string (pp
, "<unnamed type>");
1781 case REFERENCE_TYPE
:
1782 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1784 if (TREE_TYPE (node
) == NULL
)
1786 pp_string (pp
, str
);
1787 pp_string (pp
, "<null type>");
1789 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1791 tree fnode
= TREE_TYPE (node
);
1793 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1796 pp_string (pp
, str
);
1797 if (TYPE_IDENTIFIER (node
))
1798 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1799 else if (flags
& TDF_NOUID
)
1800 pp_printf (pp
, "<Txxxx>");
1802 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1804 pp_right_paren (pp
);
1805 dump_function_declaration (pp
, fnode
, spc
, flags
);
1809 unsigned int quals
= TYPE_QUALS (node
);
1811 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1813 pp_string (pp
, str
);
1815 if (quals
& TYPE_QUAL_CONST
)
1816 pp_string (pp
, " const");
1817 if (quals
& TYPE_QUAL_VOLATILE
)
1818 pp_string (pp
, " volatile");
1819 if (quals
& TYPE_QUAL_RESTRICT
)
1820 pp_string (pp
, " restrict");
1822 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1824 pp_string (pp
, " <address-space-");
1825 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1829 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1830 pp_string (pp
, " {ref-all}");
1839 dump_mem_ref (pp
, node
, spc
, flags
);
1842 case TARGET_MEM_REF
:
1844 const char *sep
= "";
1847 pp_string (pp
, "MEM[");
1849 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1851 pp_string (pp
, sep
);
1853 pp_string (pp
, "symbol: ");
1854 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1859 pp_string (pp
, sep
);
1861 pp_string (pp
, "base: ");
1862 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1864 tmp
= TMR_INDEX2 (node
);
1867 pp_string (pp
, sep
);
1869 pp_string (pp
, "base: ");
1870 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1872 tmp
= TMR_INDEX (node
);
1875 pp_string (pp
, sep
);
1877 pp_string (pp
, "index: ");
1878 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1880 tmp
= TMR_STEP (node
);
1883 pp_string (pp
, sep
);
1885 pp_string (pp
, "step: ");
1886 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1888 tmp
= TMR_OFFSET (node
);
1891 pp_string (pp
, sep
);
1893 pp_string (pp
, "offset: ");
1894 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1896 pp_right_bracket (pp
);
1904 /* Print the innermost component type. */
1905 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1906 tmp
= TREE_TYPE (tmp
))
1908 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1910 /* Print the dimensions. */
1911 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1912 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1918 case QUAL_UNION_TYPE
:
1920 unsigned int quals
= TYPE_QUALS (node
);
1922 if (quals
& TYPE_QUAL_ATOMIC
)
1923 pp_string (pp
, "atomic ");
1924 if (quals
& TYPE_QUAL_CONST
)
1925 pp_string (pp
, "const ");
1926 if (quals
& TYPE_QUAL_VOLATILE
)
1927 pp_string (pp
, "volatile ");
1929 /* Print the name of the structure. */
1930 if (TREE_CODE (node
) == RECORD_TYPE
)
1931 pp_string (pp
, "struct ");
1932 else if (TREE_CODE (node
) == UNION_TYPE
)
1933 pp_string (pp
, "union ");
1935 if (TYPE_NAME (node
))
1936 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1937 else if (!(flags
& TDF_SLIM
))
1938 /* FIXME: If we eliminate the 'else' above and attempt
1939 to show the fields for named types, we may get stuck
1940 following a cycle of pointers to structs. The alleged
1941 self-reference check in print_struct_decl will not detect
1942 cycles involving more than one pointer or struct type. */
1943 print_struct_decl (pp
, node
, spc
, flags
);
1952 if (flags
& TDF_GIMPLE
1953 && (POINTER_TYPE_P (TREE_TYPE (node
))
1954 || (TYPE_PRECISION (TREE_TYPE (node
))
1955 < TYPE_PRECISION (integer_type_node
))
1956 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1
1957 || tree_int_cst_sgn (node
) < 0))
1959 pp_string (pp
, "_Literal (");
1960 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1961 pp_string (pp
, ") ");
1963 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
1964 && ! (flags
& TDF_GIMPLE
))
1966 /* In the case of a pointer, one may want to divide by the
1967 size of the pointed-to type. Unfortunately, this not
1968 straightforward. The C front-end maps expressions
1973 in such a way that the two INTEGER_CST nodes for "5" have
1974 different values but identical types. In the latter
1975 case, the 5 is multiplied by sizeof (int) in c-common.c
1976 (pointer_int_sum) to convert it to a byte address, and
1977 yet the type of the node is left unchanged. Argh. What
1978 is consistent though is that the number value corresponds
1979 to bytes (UNITS) offset.
1981 NB: Neither of the following divisors can be trivially
1982 used to recover the original literal:
1984 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1985 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1986 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1987 pp_string (pp
, "B"); /* pseudo-unit */
1989 else if (tree_fits_shwi_p (node
))
1990 pp_wide_integer (pp
, tree_to_shwi (node
));
1991 else if (tree_fits_uhwi_p (node
))
1992 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1995 wide_int val
= wi::to_wide (node
);
1997 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
2002 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
2003 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
2005 if ((flags
& TDF_GIMPLE
)
2006 && ! (POINTER_TYPE_P (TREE_TYPE (node
))
2007 || (TYPE_PRECISION (TREE_TYPE (node
))
2008 < TYPE_PRECISION (integer_type_node
))
2009 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
2011 if (TYPE_UNSIGNED (TREE_TYPE (node
)))
2012 pp_character (pp
, 'u');
2013 if (TYPE_PRECISION (TREE_TYPE (node
))
2014 == TYPE_PRECISION (unsigned_type_node
))
2016 else if (TYPE_PRECISION (TREE_TYPE (node
))
2017 == TYPE_PRECISION (long_unsigned_type_node
))
2018 pp_character (pp
, 'l');
2019 else if (TYPE_PRECISION (TREE_TYPE (node
))
2020 == TYPE_PRECISION (long_long_unsigned_type_node
))
2021 pp_string (pp
, "ll");
2023 if (TREE_OVERFLOW (node
))
2024 pp_string (pp
, "(OVF)");
2028 pp_string (pp
, "POLY_INT_CST [");
2029 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, 0), spc
, flags
, false);
2030 for (unsigned int i
= 1; i
< NUM_POLY_INT_COEFFS
; ++i
)
2032 pp_string (pp
, ", ");
2033 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, i
),
2036 pp_string (pp
, "]");
2040 /* Code copied from print_node. */
2043 if (TREE_OVERFLOW (node
))
2044 pp_string (pp
, " overflow");
2046 d
= TREE_REAL_CST (node
);
2047 if (REAL_VALUE_ISINF (d
))
2048 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
2049 else if (REAL_VALUE_ISNAN (d
))
2050 pp_string (pp
, " Nan");
2054 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
2055 pp_string (pp
, string
);
2063 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
2064 pp_string (pp
, string
);
2069 pp_string (pp
, "__complex__ (");
2070 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
2071 pp_string (pp
, ", ");
2072 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
2073 pp_right_paren (pp
);
2078 pp_string (pp
, "\"");
2079 if (unsigned nbytes
= TREE_STRING_LENGTH (node
))
2080 pretty_print_string (pp
, TREE_STRING_POINTER (node
), nbytes
);
2081 pp_string (pp
, "\"");
2088 if (flags
& TDF_GIMPLE
)
2090 pp_string (pp
, "_Literal (");
2091 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2092 pp_string (pp
, ") ");
2094 pp_string (pp
, "{ ");
2095 unsigned HOST_WIDE_INT nunits
;
2096 if (!VECTOR_CST_NELTS (node
).is_constant (&nunits
))
2097 nunits
= vector_cst_encoded_nelts (node
);
2098 for (i
= 0; i
< nunits
; ++i
)
2101 pp_string (pp
, ", ");
2102 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
2105 if (!VECTOR_CST_NELTS (node
).is_constant ())
2106 pp_string (pp
, ", ...");
2107 pp_string (pp
, " }");
2113 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2115 if (TREE_CODE (node
) == METHOD_TYPE
)
2117 if (TYPE_METHOD_BASETYPE (node
))
2118 dump_generic_node (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
2121 pp_string (pp
, "<null method basetype>");
2122 pp_colon_colon (pp
);
2124 if (TYPE_IDENTIFIER (node
))
2125 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
2126 else if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
2127 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
2128 else if (flags
& TDF_NOUID
)
2129 pp_printf (pp
, "<Txxxx>");
2131 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
2132 dump_function_declaration (pp
, node
, spc
, flags
);
2137 dump_decl_name (pp
, node
, flags
);
2141 if (DECL_NAME (node
))
2142 dump_decl_name (pp
, node
, flags
);
2143 else if (LABEL_DECL_UID (node
) != -1)
2145 if (flags
& TDF_GIMPLE
)
2146 pp_printf (pp
, "L%d", (int) LABEL_DECL_UID (node
));
2148 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
2152 if (flags
& TDF_NOUID
)
2153 pp_string (pp
, "<D.xxxx>");
2156 if (flags
& TDF_GIMPLE
)
2157 pp_printf (pp
, "<D%u>", DECL_UID (node
));
2159 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
2165 if (DECL_IS_BUILTIN (node
))
2167 /* Don't print the declaration of built-in types. */
2170 if (DECL_NAME (node
))
2171 dump_decl_name (pp
, node
, flags
);
2172 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
2174 pp_string (pp
, (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
2175 ? "union" : "struct "));
2176 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2179 pp_string (pp
, "<anon>");
2185 case DEBUG_EXPR_DECL
:
2186 case NAMESPACE_DECL
:
2188 dump_decl_name (pp
, node
, flags
);
2192 pp_string (pp
, "<retval>");
2196 op0
= TREE_OPERAND (node
, 0);
2199 && (TREE_CODE (op0
) == INDIRECT_REF
2200 || (TREE_CODE (op0
) == MEM_REF
2201 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
2202 && integer_zerop (TREE_OPERAND (op0
, 1))
2203 /* Dump the types of INTEGER_CSTs explicitly, for we
2204 can't infer them and MEM_ATTR caching will share
2205 MEM_REFs with differently-typed op0s. */
2206 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
2207 /* Released SSA_NAMES have no TREE_TYPE. */
2208 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
2209 /* Same pointer types, but ignoring POINTER_TYPE vs.
2211 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2212 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2213 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2214 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2215 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2216 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2217 /* Same value types ignoring qualifiers. */
2218 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
2219 == TYPE_MAIN_VARIANT
2220 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
2221 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
2223 op0
= TREE_OPERAND (op0
, 0);
2226 if (op_prio (op0
) < op_prio (node
))
2228 dump_generic_node (pp
, op0
, spc
, flags
, false);
2229 if (op_prio (op0
) < op_prio (node
))
2230 pp_right_paren (pp
);
2231 pp_string (pp
, str
);
2232 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2233 op0
= component_ref_field_offset (node
);
2234 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
2236 pp_string (pp
, "{off: ");
2237 dump_generic_node (pp
, op0
, spc
, flags
, false);
2238 pp_right_brace (pp
);
2243 if (flags
& TDF_GIMPLE
)
2245 pp_string (pp
, "__BIT_FIELD_REF <");
2246 dump_generic_node (pp
, TREE_TYPE (node
),
2247 spc
, flags
| TDF_SLIM
, false);
2248 if (TYPE_ALIGN (TREE_TYPE (node
))
2249 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
2251 pp_string (pp
, ", ");
2252 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
2255 pp_string (pp
, " (");
2256 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
,
2257 flags
| TDF_SLIM
, false);
2258 pp_string (pp
, ", ");
2259 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
,
2260 flags
| TDF_SLIM
, false);
2261 pp_string (pp
, ", ");
2262 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
,
2263 flags
| TDF_SLIM
, false);
2264 pp_right_paren (pp
);
2268 pp_string (pp
, "BIT_FIELD_REF <");
2269 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2270 pp_string (pp
, ", ");
2271 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2272 pp_string (pp
, ", ");
2273 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2278 case BIT_INSERT_EXPR
:
2279 pp_string (pp
, "BIT_INSERT_EXPR <");
2280 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2281 pp_string (pp
, ", ");
2282 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2283 pp_string (pp
, ", ");
2284 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2285 pp_string (pp
, " (");
2286 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
2288 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
2290 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
2292 pp_string (pp
, " bits)>");
2296 case ARRAY_RANGE_REF
:
2297 op0
= TREE_OPERAND (node
, 0);
2298 if (op_prio (op0
) < op_prio (node
))
2300 dump_generic_node (pp
, op0
, spc
, flags
, false);
2301 if (op_prio (op0
) < op_prio (node
))
2302 pp_right_paren (pp
);
2303 pp_left_bracket (pp
);
2304 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2305 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
2306 pp_string (pp
, " ...");
2307 pp_right_bracket (pp
);
2309 op0
= array_ref_low_bound (node
);
2310 op1
= array_ref_element_size (node
);
2312 if (!integer_zerop (op0
)
2313 || TREE_OPERAND (node
, 2)
2314 || TREE_OPERAND (node
, 3))
2316 pp_string (pp
, "{lb: ");
2317 dump_generic_node (pp
, op0
, spc
, flags
, false);
2318 pp_string (pp
, " sz: ");
2319 dump_generic_node (pp
, op1
, spc
, flags
, false);
2320 pp_right_brace (pp
);
2326 unsigned HOST_WIDE_INT ix
;
2328 bool is_struct_init
= false;
2329 bool is_array_init
= false;
2331 if (flags
& TDF_GIMPLE
)
2333 pp_string (pp
, "_Literal (");
2334 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2335 pp_string (pp
, ") ");
2338 if (TREE_CLOBBER_P (node
))
2339 pp_string (pp
, "CLOBBER");
2340 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
2341 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
2342 is_struct_init
= true;
2343 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
2344 && TYPE_DOMAIN (TREE_TYPE (node
))
2345 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
2346 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
2349 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
2350 is_array_init
= true;
2351 curidx
= wi::to_widest (minv
);
2353 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
2360 dump_generic_node (pp
, field
, spc
, flags
, false);
2363 else if (is_array_init
2364 && (TREE_CODE (field
) != INTEGER_CST
2365 || curidx
!= wi::to_widest (field
)))
2367 pp_left_bracket (pp
);
2368 if (TREE_CODE (field
) == RANGE_EXPR
)
2370 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
2372 pp_string (pp
, " ... ");
2373 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
2375 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
2376 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
2379 dump_generic_node (pp
, field
, spc
, flags
, false);
2380 if (TREE_CODE (field
) == INTEGER_CST
)
2381 curidx
= wi::to_widest (field
);
2382 pp_string (pp
, "]=");
2387 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
2388 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
2389 val
= TREE_OPERAND (val
, 0);
2390 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
2391 dump_decl_name (pp
, val
, flags
);
2393 dump_generic_node (pp
, val
, spc
, flags
, false);
2394 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2400 pp_right_brace (pp
);
2407 if (flags
& TDF_SLIM
)
2409 pp_string (pp
, "<COMPOUND_EXPR>");
2413 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2414 spc
, flags
, !(flags
& TDF_SLIM
));
2415 if (flags
& TDF_SLIM
)
2416 newline_and_indent (pp
, spc
);
2423 for (tp
= &TREE_OPERAND (node
, 1);
2424 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2425 tp
= &TREE_OPERAND (*tp
, 1))
2427 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2428 spc
, flags
, !(flags
& TDF_SLIM
));
2429 if (flags
& TDF_SLIM
)
2430 newline_and_indent (pp
, spc
);
2438 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2442 case STATEMENT_LIST
:
2444 tree_stmt_iterator si
;
2447 if (flags
& TDF_SLIM
)
2449 pp_string (pp
, "<STATEMENT_LIST>");
2453 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2456 newline_and_indent (pp
, spc
);
2459 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2466 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2471 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2476 pp_string (pp
, "TARGET_EXPR <");
2477 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2480 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2485 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2490 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2492 pp_string (pp
, "if (");
2493 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2494 pp_right_paren (pp
);
2495 /* The lowered cond_exprs should always be printed in full. */
2496 if (COND_EXPR_THEN (node
)
2497 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2498 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2499 && COND_EXPR_ELSE (node
)
2500 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2501 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2504 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2506 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2508 pp_string (pp
, " else ");
2509 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2513 else if (!(flags
& TDF_SLIM
))
2515 /* Output COND_EXPR_THEN. */
2516 if (COND_EXPR_THEN (node
))
2518 newline_and_indent (pp
, spc
+2);
2520 newline_and_indent (pp
, spc
+4);
2521 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2523 newline_and_indent (pp
, spc
+2);
2524 pp_right_brace (pp
);
2527 /* Output COND_EXPR_ELSE. */
2528 if (COND_EXPR_ELSE (node
)
2529 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2531 newline_and_indent (pp
, spc
);
2532 pp_string (pp
, "else");
2533 newline_and_indent (pp
, spc
+2);
2535 newline_and_indent (pp
, spc
+4);
2536 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2538 newline_and_indent (pp
, spc
+2);
2539 pp_right_brace (pp
);
2546 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2550 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2554 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2560 if (!(flags
& TDF_SLIM
))
2562 if (BIND_EXPR_VARS (node
))
2566 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2568 print_declaration (pp
, op0
, spc
+2, flags
);
2573 newline_and_indent (pp
, spc
+2);
2574 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2575 newline_and_indent (pp
, spc
);
2576 pp_right_brace (pp
);
2582 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2583 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2587 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2590 /* Print parameters. */
2595 call_expr_arg_iterator iter
;
2596 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2598 dump_generic_node (pp
, arg
, spc
, flags
, false);
2599 if (more_call_expr_args_p (&iter
))
2606 if (CALL_EXPR_VA_ARG_PACK (node
))
2608 if (call_expr_nargs (node
) > 0)
2613 pp_string (pp
, "__builtin_va_arg_pack ()");
2615 pp_right_paren (pp
);
2617 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2620 pp_string (pp
, " [static-chain: ");
2621 dump_generic_node (pp
, op1
, spc
, flags
, false);
2622 pp_right_bracket (pp
);
2625 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2626 pp_string (pp
, " [return slot optimization]");
2627 if (CALL_EXPR_TAILCALL (node
))
2628 pp_string (pp
, " [tail call]");
2631 case WITH_CLEANUP_EXPR
:
2635 case CLEANUP_POINT_EXPR
:
2636 pp_string (pp
, "<<cleanup_point ");
2637 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2638 pp_string (pp
, ">>");
2641 case PLACEHOLDER_EXPR
:
2642 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2643 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2647 /* Binary arithmetic and logic expressions. */
2648 case WIDEN_SUM_EXPR
:
2649 case WIDEN_MULT_EXPR
:
2651 case MULT_HIGHPART_EXPR
:
2653 case POINTER_PLUS_EXPR
:
2654 case POINTER_DIFF_EXPR
:
2656 case TRUNC_DIV_EXPR
:
2658 case FLOOR_DIV_EXPR
:
2659 case ROUND_DIV_EXPR
:
2660 case TRUNC_MOD_EXPR
:
2662 case FLOOR_MOD_EXPR
:
2663 case ROUND_MOD_EXPR
:
2665 case EXACT_DIV_EXPR
:
2670 case WIDEN_LSHIFT_EXPR
:
2674 case TRUTH_ANDIF_EXPR
:
2675 case TRUTH_ORIF_EXPR
:
2676 case TRUTH_AND_EXPR
:
2678 case TRUTH_XOR_EXPR
:
2692 case UNORDERED_EXPR
:
2694 const char *op
= op_symbol (node
);
2695 op0
= TREE_OPERAND (node
, 0);
2696 op1
= TREE_OPERAND (node
, 1);
2698 /* When the operands are expressions with less priority,
2699 keep semantics of the tree representation. */
2700 if (op_prio (op0
) <= op_prio (node
))
2703 dump_generic_node (pp
, op0
, spc
, flags
, false);
2704 pp_right_paren (pp
);
2707 dump_generic_node (pp
, op0
, spc
, flags
, false);
2713 /* When the operands are expressions with less priority,
2714 keep semantics of the tree representation. */
2715 if (op_prio (op1
) <= op_prio (node
))
2718 dump_generic_node (pp
, op1
, spc
, flags
, false);
2719 pp_right_paren (pp
);
2722 dump_generic_node (pp
, op1
, spc
, flags
, false);
2726 /* Unary arithmetic and logic expressions. */
2729 case TRUTH_NOT_EXPR
:
2731 case PREDECREMENT_EXPR
:
2732 case PREINCREMENT_EXPR
:
2734 if (TREE_CODE (node
) == ADDR_EXPR
2735 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2736 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2737 ; /* Do not output '&' for strings and function pointers. */
2739 pp_string (pp
, op_symbol (node
));
2741 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2744 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2745 pp_right_paren (pp
);
2748 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2751 case POSTDECREMENT_EXPR
:
2752 case POSTINCREMENT_EXPR
:
2753 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2756 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2757 pp_right_paren (pp
);
2760 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2761 pp_string (pp
, op_symbol (node
));
2765 pp_string (pp
, "MIN_EXPR <");
2766 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2767 pp_string (pp
, ", ");
2768 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2773 pp_string (pp
, "MAX_EXPR <");
2774 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2775 pp_string (pp
, ", ");
2776 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2781 pp_string (pp
, "ABS_EXPR <");
2782 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2787 pp_string (pp
, "ABSU_EXPR <");
2788 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2796 case ADDR_SPACE_CONVERT_EXPR
:
2797 case FIXED_CONVERT_EXPR
:
2798 case FIX_TRUNC_EXPR
:
2801 type
= TREE_TYPE (node
);
2802 op0
= TREE_OPERAND (node
, 0);
2803 if (type
!= TREE_TYPE (op0
))
2806 dump_generic_node (pp
, type
, spc
, flags
, false);
2807 pp_string (pp
, ") ");
2809 if (op_prio (op0
) < op_prio (node
))
2811 dump_generic_node (pp
, op0
, spc
, flags
, false);
2812 if (op_prio (op0
) < op_prio (node
))
2813 pp_right_paren (pp
);
2816 case VIEW_CONVERT_EXPR
:
2817 if (flags
& TDF_GIMPLE
)
2818 pp_string (pp
, "__VIEW_CONVERT <");
2820 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2821 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2822 pp_string (pp
, ">(");
2823 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2824 pp_right_paren (pp
);
2828 pp_string (pp
, "((");
2829 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2830 pp_string (pp
, "))");
2833 case NON_LVALUE_EXPR
:
2834 pp_string (pp
, "NON_LVALUE_EXPR <");
2835 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2840 pp_string (pp
, "SAVE_EXPR <");
2841 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2846 pp_string (pp
, "COMPLEX_EXPR <");
2847 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2848 pp_string (pp
, ", ");
2849 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2854 pp_string (pp
, "CONJ_EXPR <");
2855 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2860 if (flags
& TDF_GIMPLE
)
2862 pp_string (pp
, "__real ");
2863 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2867 pp_string (pp
, "REALPART_EXPR <");
2868 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2874 if (flags
& TDF_GIMPLE
)
2876 pp_string (pp
, "__imag ");
2877 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2881 pp_string (pp
, "IMAGPART_EXPR <");
2882 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2888 pp_string (pp
, "VA_ARG_EXPR <");
2889 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2893 case TRY_FINALLY_EXPR
:
2894 case TRY_CATCH_EXPR
:
2895 pp_string (pp
, "try");
2896 newline_and_indent (pp
, spc
+2);
2898 newline_and_indent (pp
, spc
+4);
2899 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2900 newline_and_indent (pp
, spc
+2);
2901 pp_right_brace (pp
);
2902 newline_and_indent (pp
, spc
);
2903 if (TREE_CODE (node
) == TRY_CATCH_EXPR
)
2905 node
= TREE_OPERAND (node
, 1);
2906 pp_string (pp
, "catch");
2910 gcc_assert (TREE_CODE (node
) == TRY_FINALLY_EXPR
);
2911 node
= TREE_OPERAND (node
, 1);
2912 pp_string (pp
, "finally");
2913 if (TREE_CODE (node
) == EH_ELSE_EXPR
)
2915 newline_and_indent (pp
, spc
+2);
2917 newline_and_indent (pp
, spc
+4);
2918 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4,
2920 newline_and_indent (pp
, spc
+2);
2921 pp_right_brace (pp
);
2922 newline_and_indent (pp
, spc
);
2923 node
= TREE_OPERAND (node
, 1);
2924 pp_string (pp
, "else");
2927 newline_and_indent (pp
, spc
+2);
2929 newline_and_indent (pp
, spc
+4);
2930 dump_generic_node (pp
, node
, spc
+4, flags
, true);
2931 newline_and_indent (pp
, spc
+2);
2932 pp_right_brace (pp
);
2937 pp_string (pp
, "catch (");
2938 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2939 pp_right_paren (pp
);
2940 newline_and_indent (pp
, spc
+2);
2942 newline_and_indent (pp
, spc
+4);
2943 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2944 newline_and_indent (pp
, spc
+2);
2945 pp_right_brace (pp
);
2949 case EH_FILTER_EXPR
:
2950 pp_string (pp
, "<<<eh_filter (");
2951 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2952 pp_string (pp
, ")>>>");
2953 newline_and_indent (pp
, spc
+2);
2955 newline_and_indent (pp
, spc
+4);
2956 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2957 newline_and_indent (pp
, spc
+2);
2958 pp_right_brace (pp
);
2963 op0
= TREE_OPERAND (node
, 0);
2964 /* If this is for break or continue, don't bother printing it. */
2965 if (DECL_NAME (op0
))
2967 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2968 if (strcmp (name
, "break") == 0
2969 || strcmp (name
, "continue") == 0)
2972 dump_generic_node (pp
, op0
, spc
, flags
, false);
2974 if (DECL_NONLOCAL (op0
))
2975 pp_string (pp
, " [non-local]");
2979 pp_string (pp
, "while (1)");
2980 if (!(flags
& TDF_SLIM
))
2982 newline_and_indent (pp
, spc
+2);
2984 newline_and_indent (pp
, spc
+4);
2985 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2986 newline_and_indent (pp
, spc
+2);
2987 pp_right_brace (pp
);
2993 pp_string (pp
, "// predicted ");
2994 if (PREDICT_EXPR_OUTCOME (node
))
2995 pp_string (pp
, "likely by ");
2997 pp_string (pp
, "unlikely by ");
2998 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2999 pp_string (pp
, " predictor.");
3003 pp_string (pp
, "ANNOTATE_EXPR <");
3004 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3005 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
3007 case annot_expr_ivdep_kind
:
3008 pp_string (pp
, ", ivdep");
3010 case annot_expr_unroll_kind
:
3011 pp_printf (pp
, ", unroll %d",
3012 (int) TREE_INT_CST_LOW (TREE_OPERAND (node
, 2)));
3014 case annot_expr_no_vector_kind
:
3015 pp_string (pp
, ", no-vector");
3017 case annot_expr_vector_kind
:
3018 pp_string (pp
, ", vector");
3020 case annot_expr_parallel_kind
:
3021 pp_string (pp
, ", parallel");
3030 pp_string (pp
, "return");
3031 op0
= TREE_OPERAND (node
, 0);
3035 if (TREE_CODE (op0
) == MODIFY_EXPR
)
3036 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
3039 dump_generic_node (pp
, op0
, spc
, flags
, false);
3044 pp_string (pp
, "if (");
3045 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3046 pp_string (pp
, ") break");
3050 pp_string (pp
, "switch (");
3051 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
3052 pp_right_paren (pp
);
3053 if (!(flags
& TDF_SLIM
))
3055 newline_and_indent (pp
, spc
+2);
3057 if (SWITCH_BODY (node
))
3059 newline_and_indent (pp
, spc
+4);
3060 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
3063 newline_and_indent (pp
, spc
+2);
3064 pp_right_brace (pp
);
3070 op0
= GOTO_DESTINATION (node
);
3071 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
3073 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
3074 if (strcmp (name
, "break") == 0
3075 || strcmp (name
, "continue") == 0)
3077 pp_string (pp
, name
);
3081 pp_string (pp
, "goto ");
3082 dump_generic_node (pp
, op0
, spc
, flags
, false);
3086 pp_string (pp
, "__asm__");
3087 if (ASM_VOLATILE_P (node
))
3088 pp_string (pp
, " __volatile__");
3090 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
3092 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
3094 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
3095 if (ASM_CLOBBERS (node
))
3098 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
3100 pp_right_paren (pp
);
3103 case CASE_LABEL_EXPR
:
3104 if (CASE_LOW (node
) && CASE_HIGH (node
))
3106 pp_string (pp
, "case ");
3107 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
3108 pp_string (pp
, " ... ");
3109 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
3111 else if (CASE_LOW (node
))
3113 pp_string (pp
, "case ");
3114 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
3117 pp_string (pp
, "default");
3122 pp_string (pp
, "OBJ_TYPE_REF(");
3123 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
3125 /* We omit the class type for -fcompare-debug because we may
3126 drop TYPE_BINFO early depending on debug info, and then
3127 virtual_method_call_p would return false, whereas when
3128 TYPE_BINFO is preserved it may still return true and then
3129 we'd print the class type. Compare tree and rtl dumps for
3130 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
3131 for example, at occurrences of OBJ_TYPE_REF. */
3132 if (!(flags
& (TDF_SLIM
| TDF_COMPARE_DEBUG
))
3133 && virtual_method_call_p (node
))
3135 pp_string (pp
, "(");
3136 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
3137 pp_string (pp
, ")");
3139 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
3141 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
3142 pp_right_paren (pp
);
3146 if (SSA_NAME_IDENTIFIER (node
))
3148 if ((flags
& TDF_NOUID
)
3149 && SSA_NAME_VAR (node
)
3150 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
3151 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
3152 else if (! (flags
& TDF_GIMPLE
)
3153 || SSA_NAME_VAR (node
))
3154 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
3158 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
3159 if (SSA_NAME_IS_DEFAULT_DEF (node
))
3160 pp_string (pp
, "(D)");
3161 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
3162 pp_string (pp
, "(ab)");
3165 case WITH_SIZE_EXPR
:
3166 pp_string (pp
, "WITH_SIZE_EXPR <");
3167 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3168 pp_string (pp
, ", ");
3169 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3174 pp_string (pp
, "ASSERT_EXPR <");
3175 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
3176 pp_string (pp
, ", ");
3177 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
3182 pp_string (pp
, "scev_known");
3185 case SCEV_NOT_KNOWN
:
3186 pp_string (pp
, "scev_not_known");
3189 case POLYNOMIAL_CHREC
:
3191 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
3192 pp_string (pp
, ", +, ");
3193 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
3194 pp_printf (pp
, "}_%u", CHREC_VARIABLE (node
));
3198 case REALIGN_LOAD_EXPR
:
3199 pp_string (pp
, "REALIGN_LOAD <");
3200 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3201 pp_string (pp
, ", ");
3202 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3203 pp_string (pp
, ", ");
3204 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3209 pp_string (pp
, " VEC_COND_EXPR < ");
3210 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3211 pp_string (pp
, " , ");
3212 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3213 pp_string (pp
, " , ");
3214 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3215 pp_string (pp
, " > ");
3219 pp_string (pp
, " VEC_PERM_EXPR < ");
3220 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3221 pp_string (pp
, " , ");
3222 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3223 pp_string (pp
, " , ");
3224 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3225 pp_string (pp
, " > ");
3229 pp_string (pp
, " DOT_PROD_EXPR < ");
3230 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3231 pp_string (pp
, ", ");
3232 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3233 pp_string (pp
, ", ");
3234 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3235 pp_string (pp
, " > ");
3238 case WIDEN_MULT_PLUS_EXPR
:
3239 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
3240 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3241 pp_string (pp
, ", ");
3242 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3243 pp_string (pp
, ", ");
3244 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3245 pp_string (pp
, " > ");
3248 case WIDEN_MULT_MINUS_EXPR
:
3249 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
3250 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3251 pp_string (pp
, ", ");
3252 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3253 pp_string (pp
, ", ");
3254 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3255 pp_string (pp
, " > ");
3259 pp_string (pp
, "#pragma acc parallel");
3260 goto dump_omp_clauses_body
;
3263 pp_string (pp
, "#pragma acc kernels");
3264 goto dump_omp_clauses_body
;
3267 pp_string (pp
, "#pragma acc serial");
3268 goto dump_omp_clauses_body
;
3271 pp_string (pp
, "#pragma acc data");
3272 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
3275 case OACC_HOST_DATA
:
3276 pp_string (pp
, "#pragma acc host_data");
3277 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
3281 pp_string (pp
, "#pragma acc declare");
3282 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
3286 pp_string (pp
, "#pragma acc update");
3287 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
3290 case OACC_ENTER_DATA
:
3291 pp_string (pp
, "#pragma acc enter data");
3292 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3295 case OACC_EXIT_DATA
:
3296 pp_string (pp
, "#pragma acc exit data");
3297 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3301 pp_string (pp
, "#pragma acc cache");
3302 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
3306 pp_string (pp
, "#pragma omp parallel");
3307 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
3310 dump_omp_clauses_body
:
3311 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
3315 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
3317 newline_and_indent (pp
, spc
+ 2);
3319 newline_and_indent (pp
, spc
+ 4);
3320 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
3321 newline_and_indent (pp
, spc
+ 2);
3322 pp_right_brace (pp
);
3328 pp_string (pp
, OMP_TASK_BODY (node
) ? "#pragma omp task"
3329 : "#pragma omp taskwait");
3330 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
3334 pp_string (pp
, "#pragma omp for");
3338 pp_string (pp
, "#pragma omp simd");
3341 case OMP_DISTRIBUTE
:
3342 pp_string (pp
, "#pragma omp distribute");
3346 pp_string (pp
, "#pragma omp taskloop");
3350 pp_string (pp
, "#pragma omp loop");
3354 pp_string (pp
, "#pragma acc loop");
3358 pp_string (pp
, "#pragma omp teams");
3359 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
3362 case OMP_TARGET_DATA
:
3363 pp_string (pp
, "#pragma omp target data");
3364 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
3367 case OMP_TARGET_ENTER_DATA
:
3368 pp_string (pp
, "#pragma omp target enter data");
3369 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3373 case OMP_TARGET_EXIT_DATA
:
3374 pp_string (pp
, "#pragma omp target exit data");
3375 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3380 pp_string (pp
, "#pragma omp target");
3381 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3384 case OMP_TARGET_UPDATE
:
3385 pp_string (pp
, "#pragma omp target update");
3386 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3391 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3392 if (!(flags
& TDF_SLIM
))
3396 if (OMP_FOR_PRE_BODY (node
))
3398 newline_and_indent (pp
, spc
+ 2);
3401 newline_and_indent (pp
, spc
);
3402 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3405 if (OMP_FOR_INIT (node
))
3408 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3411 newline_and_indent (pp
, spc
);
3412 pp_string (pp
, "for (");
3413 dump_generic_node (pp
,
3414 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
3416 pp_string (pp
, "; ");
3417 dump_generic_node (pp
,
3418 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
3420 pp_string (pp
, "; ");
3421 dump_generic_node (pp
,
3422 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3424 pp_right_paren (pp
);
3427 if (OMP_FOR_BODY (node
))
3429 newline_and_indent (pp
, spc
+ 2);
3431 newline_and_indent (pp
, spc
+ 4);
3432 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3434 newline_and_indent (pp
, spc
+ 2);
3435 pp_right_brace (pp
);
3437 if (OMP_FOR_INIT (node
))
3438 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3439 if (OMP_FOR_PRE_BODY (node
))
3442 newline_and_indent (pp
, spc
+ 2);
3443 pp_right_brace (pp
);
3450 pp_string (pp
, "#pragma omp sections");
3451 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3455 pp_string (pp
, "#pragma omp section");
3459 if (OMP_SCAN_CLAUSES (node
))
3461 pp_string (pp
, "#pragma omp scan");
3462 dump_omp_clauses (pp
, OMP_SCAN_CLAUSES (node
), spc
, flags
);
3467 pp_string (pp
, "#pragma omp master");
3471 pp_string (pp
, "#pragma omp taskgroup");
3472 dump_omp_clauses (pp
, OMP_TASKGROUP_CLAUSES (node
), spc
, flags
);
3476 pp_string (pp
, "#pragma omp ordered");
3477 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3481 pp_string (pp
, "#pragma omp critical");
3482 if (OMP_CRITICAL_NAME (node
))
3486 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3488 pp_right_paren (pp
);
3490 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3494 pp_string (pp
, "#pragma omp atomic");
3495 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3496 newline_and_indent (pp
, spc
+ 2);
3497 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3501 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3504 case OMP_ATOMIC_READ
:
3505 pp_string (pp
, "#pragma omp atomic read");
3506 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3507 newline_and_indent (pp
, spc
+ 2);
3508 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3512 case OMP_ATOMIC_CAPTURE_OLD
:
3513 case OMP_ATOMIC_CAPTURE_NEW
:
3514 pp_string (pp
, "#pragma omp atomic capture");
3515 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3516 newline_and_indent (pp
, spc
+ 2);
3517 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3521 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3525 pp_string (pp
, "#pragma omp single");
3526 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3530 dump_omp_clause (pp
, node
, spc
, flags
);
3534 case TRANSACTION_EXPR
:
3535 if (TRANSACTION_EXPR_OUTER (node
))
3536 pp_string (pp
, "__transaction_atomic [[outer]]");
3537 else if (TRANSACTION_EXPR_RELAXED (node
))
3538 pp_string (pp
, "__transaction_relaxed");
3540 pp_string (pp
, "__transaction_atomic");
3541 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3543 newline_and_indent (pp
, spc
);
3545 newline_and_indent (pp
, spc
+ 2);
3546 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3547 spc
+ 2, flags
, false);
3548 newline_and_indent (pp
, spc
);
3549 pp_right_brace (pp
);
3554 case VEC_SERIES_EXPR
:
3555 case VEC_WIDEN_MULT_HI_EXPR
:
3556 case VEC_WIDEN_MULT_LO_EXPR
:
3557 case VEC_WIDEN_MULT_EVEN_EXPR
:
3558 case VEC_WIDEN_MULT_ODD_EXPR
:
3559 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3560 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3562 for (str
= get_tree_code_name (code
); *str
; str
++)
3563 pp_character (pp
, TOUPPER (*str
));
3564 pp_string (pp
, " < ");
3565 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3566 pp_string (pp
, ", ");
3567 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3568 pp_string (pp
, " > ");
3571 case VEC_DUPLICATE_EXPR
:
3573 for (str
= get_tree_code_name (code
); *str
; str
++)
3574 pp_character (pp
, TOUPPER (*str
));
3575 pp_string (pp
, " < ");
3576 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3577 pp_string (pp
, " > ");
3580 case VEC_UNPACK_HI_EXPR
:
3581 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3582 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3583 pp_string (pp
, " > ");
3586 case VEC_UNPACK_LO_EXPR
:
3587 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3588 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3589 pp_string (pp
, " > ");
3592 case VEC_UNPACK_FLOAT_HI_EXPR
:
3593 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3594 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3595 pp_string (pp
, " > ");
3598 case VEC_UNPACK_FLOAT_LO_EXPR
:
3599 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3600 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3601 pp_string (pp
, " > ");
3604 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3605 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
3606 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3607 pp_string (pp
, " > ");
3610 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3611 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
3612 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3613 pp_string (pp
, " > ");
3616 case VEC_PACK_TRUNC_EXPR
:
3617 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3618 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3619 pp_string (pp
, ", ");
3620 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3621 pp_string (pp
, " > ");
3624 case VEC_PACK_SAT_EXPR
:
3625 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3626 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3627 pp_string (pp
, ", ");
3628 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3629 pp_string (pp
, " > ");
3632 case VEC_PACK_FIX_TRUNC_EXPR
:
3633 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3634 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3635 pp_string (pp
, ", ");
3636 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3637 pp_string (pp
, " > ");
3640 case VEC_PACK_FLOAT_EXPR
:
3641 pp_string (pp
, " VEC_PACK_FLOAT_EXPR < ");
3642 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3643 pp_string (pp
, ", ");
3644 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3645 pp_string (pp
, " > ");
3649 dump_block_node (pp
, node
, spc
, flags
);
3652 case DEBUG_BEGIN_STMT
:
3653 pp_string (pp
, "# DEBUG BEGIN STMT");
3660 if (is_stmt
&& is_expr
)
3666 /* Print the declaration of a variable. */
3669 print_declaration (pretty_printer
*pp
, tree t
, int spc
, dump_flags_t flags
)
3673 if (TREE_CODE(t
) == NAMELIST_DECL
)
3675 pp_string(pp
, "namelist ");
3676 dump_decl_name (pp
, t
, flags
);
3681 if (TREE_CODE (t
) == TYPE_DECL
)
3682 pp_string (pp
, "typedef ");
3684 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3685 pp_string (pp
, "register ");
3687 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3688 pp_string (pp
, "extern ");
3689 else if (TREE_STATIC (t
))
3690 pp_string (pp
, "static ");
3692 /* Print the type and name. */
3693 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3697 /* Print array's type. */
3698 tmp
= TREE_TYPE (t
);
3699 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3700 tmp
= TREE_TYPE (tmp
);
3701 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3703 /* Print variable's name. */
3705 dump_generic_node (pp
, t
, spc
, flags
, false);
3707 /* Print the dimensions. */
3708 tmp
= TREE_TYPE (t
);
3709 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3711 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3712 tmp
= TREE_TYPE (tmp
);
3715 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3717 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3719 dump_decl_name (pp
, t
, flags
);
3720 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3724 /* Print type declaration. */
3725 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3727 /* Print variable's name. */
3729 dump_generic_node (pp
, t
, spc
, flags
, false);
3732 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
3734 pp_string (pp
, " __asm__ ");
3736 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3737 pp_right_paren (pp
);
3740 /* The initial value of a function serves to determine whether the function
3741 is declared or defined. So the following does not apply to function
3743 if (TREE_CODE (t
) != FUNCTION_DECL
)
3745 /* Print the initial value. */
3746 if (DECL_INITIAL (t
))
3751 if (!(flags
& TDF_SLIM
))
3752 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3754 pp_string (pp
, "<<< omitted >>>");
3758 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3760 pp_string (pp
, " [value-expr: ");
3761 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3762 pp_right_bracket (pp
);
3769 /* Prints a structure: name, fields, and methods.
3770 FIXME: Still incomplete. */
3773 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
3776 /* Print the name of the structure. */
3777 if (TYPE_NAME (node
))
3780 if (TREE_CODE (node
) == RECORD_TYPE
)
3781 pp_string (pp
, "struct ");
3782 else if ((TREE_CODE (node
) == UNION_TYPE
3783 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3784 pp_string (pp
, "union ");
3786 dump_generic_node (pp
, TYPE_NAME (node
), spc
, TDF_NONE
, false);
3789 /* Print the contents of the structure. */
3795 /* Print the fields of the structure. */
3798 tmp
= TYPE_FIELDS (node
);
3801 /* Avoid to print recursively the structure. */
3802 /* FIXME : Not implemented correctly...,
3803 what about the case when we have a cycle in the contain graph? ...
3804 Maybe this could be solved by looking at the scope in which the
3805 structure was declared. */
3806 if (TREE_TYPE (tmp
) != node
3807 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3808 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3810 print_declaration (pp
, tmp
, spc
+2, flags
);
3813 tmp
= DECL_CHAIN (tmp
);
3817 pp_right_brace (pp
);
3820 /* Return the priority of the operator CODE.
3822 From lowest to highest precedence with either left-to-right (L-R)
3823 or right-to-left (R-L) associativity]:
3826 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3838 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3839 15 [L-R] fn() [] -> .
3841 unary +, - and * have higher precedence than the corresponding binary
3845 op_code_prio (enum tree_code code
)
3862 case TRUTH_ORIF_EXPR
:
3865 case TRUTH_AND_EXPR
:
3866 case TRUTH_ANDIF_EXPR
:
3873 case TRUTH_XOR_EXPR
:
3890 case UNORDERED_EXPR
:
3901 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3902 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3903 case WIDEN_LSHIFT_EXPR
:
3906 case WIDEN_SUM_EXPR
:
3908 case POINTER_PLUS_EXPR
:
3909 case POINTER_DIFF_EXPR
:
3913 case VEC_WIDEN_MULT_HI_EXPR
:
3914 case VEC_WIDEN_MULT_LO_EXPR
:
3915 case WIDEN_MULT_EXPR
:
3917 case WIDEN_MULT_PLUS_EXPR
:
3918 case WIDEN_MULT_MINUS_EXPR
:
3920 case MULT_HIGHPART_EXPR
:
3921 case TRUNC_DIV_EXPR
:
3923 case FLOOR_DIV_EXPR
:
3924 case ROUND_DIV_EXPR
:
3926 case EXACT_DIV_EXPR
:
3927 case TRUNC_MOD_EXPR
:
3929 case FLOOR_MOD_EXPR
:
3930 case ROUND_MOD_EXPR
:
3933 case TRUTH_NOT_EXPR
:
3935 case POSTINCREMENT_EXPR
:
3936 case POSTDECREMENT_EXPR
:
3937 case PREINCREMENT_EXPR
:
3938 case PREDECREMENT_EXPR
:
3944 case FIX_TRUNC_EXPR
:
3950 case ARRAY_RANGE_REF
:
3954 /* Special expressions. */
3960 case VEC_UNPACK_HI_EXPR
:
3961 case VEC_UNPACK_LO_EXPR
:
3962 case VEC_UNPACK_FLOAT_HI_EXPR
:
3963 case VEC_UNPACK_FLOAT_LO_EXPR
:
3964 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3965 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3966 case VEC_PACK_TRUNC_EXPR
:
3967 case VEC_PACK_SAT_EXPR
:
3971 /* Return an arbitrarily high precedence to avoid surrounding single
3972 VAR_DECLs in ()s. */
3977 /* Return the priority of the operator OP. */
3980 op_prio (const_tree op
)
3982 enum tree_code code
;
3987 code
= TREE_CODE (op
);
3988 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3989 return op_prio (TREE_OPERAND (op
, 0));
3991 return op_code_prio (code
);
3994 /* Return the symbol associated with operator CODE. */
3997 op_symbol_code (enum tree_code code
)
4005 case TRUTH_ORIF_EXPR
:
4008 case TRUTH_AND_EXPR
:
4009 case TRUTH_ANDIF_EXPR
:
4015 case TRUTH_XOR_EXPR
:
4025 case UNORDERED_EXPR
:
4071 case WIDEN_LSHIFT_EXPR
:
4074 case POINTER_PLUS_EXPR
:
4080 case WIDEN_SUM_EXPR
:
4083 case WIDEN_MULT_EXPR
:
4086 case MULT_HIGHPART_EXPR
:
4091 case POINTER_DIFF_EXPR
:
4097 case TRUTH_NOT_EXPR
:
4104 case TRUNC_DIV_EXPR
:
4111 case FLOOR_DIV_EXPR
:
4114 case ROUND_DIV_EXPR
:
4117 case EXACT_DIV_EXPR
:
4120 case TRUNC_MOD_EXPR
:
4126 case FLOOR_MOD_EXPR
:
4129 case ROUND_MOD_EXPR
:
4132 case PREDECREMENT_EXPR
:
4135 case PREINCREMENT_EXPR
:
4138 case POSTDECREMENT_EXPR
:
4141 case POSTINCREMENT_EXPR
:
4151 return "<<< ??? >>>";
4155 /* Return the symbol associated with operator OP. */
4158 op_symbol (const_tree op
)
4160 return op_symbol_code (TREE_CODE (op
));
4163 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
4164 the gimple_call_fn of a GIMPLE_CALL. */
4167 print_call_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
4171 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
4172 op0
= TREE_OPERAND (op0
, 0);
4175 switch (TREE_CODE (op0
))
4180 dump_function_name (pp
, op0
, flags
);
4186 op0
= TREE_OPERAND (op0
, 0);
4191 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
4192 pp_string (pp
, ") ? ");
4193 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
4194 pp_string (pp
, " : ");
4195 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
4199 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
4200 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
4202 dump_generic_node (pp
, op0
, 0, flags
, false);
4206 if (integer_zerop (TREE_OPERAND (op0
, 1)))
4208 op0
= TREE_OPERAND (op0
, 0);
4215 dump_generic_node (pp
, op0
, 0, flags
, false);
4223 /* Print the first N characters in the array STR, replacing non-printable
4224 characters (including embedded nuls) with unambiguous escape sequences. */
4227 pretty_print_string (pretty_printer
*pp
, const char *str
, size_t n
)
4232 for ( ; n
; --n
, ++str
)
4237 pp_string (pp
, "\\b");
4241 pp_string (pp
, "\\f");
4245 pp_string (pp
, "\\n");
4249 pp_string (pp
, "\\r");
4253 pp_string (pp
, "\\t");
4257 pp_string (pp
, "\\v");
4261 pp_string (pp
, "\\\\");
4265 pp_string (pp
, "\\\"");
4269 pp_string (pp
, "\\'");
4273 if (str
[0] || n
> 1)
4275 if (!ISPRINT (str
[0]))
4278 sprintf (buf
, "\\x%02x", (unsigned char)str
[0]);
4279 pp_string (pp
, buf
);
4282 pp_character (pp
, str
[0]);
4290 maybe_init_pretty_print (FILE *file
)
4294 tree_pp
= new pretty_printer ();
4295 pp_needs_newline (tree_pp
) = true;
4296 pp_translate_identifiers (tree_pp
) = false;
4299 tree_pp
->buffer
->stream
= file
;
4303 newline_and_indent (pretty_printer
*pp
, int spc
)
4309 /* Handle the %K format for TEXT. Separate from default_tree_printer
4310 so it can also be used in front ends.
4311 The location LOC and BLOCK are expected to be extracted by the caller
4312 from the %K argument arg via EXPR_LOCATION(arg) and TREE_BLOCK(arg). */
4315 percent_K_format (text_info
*text
, location_t loc
, tree block
)
4317 text
->set_location (0, loc
, SHOW_RANGE_WITH_CARET
);
4318 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
4319 *pp_ti_abstract_origin (text
) = NULL
;
4322 && TREE_CODE (block
) == BLOCK
4323 && BLOCK_ABSTRACT_ORIGIN (block
))
4325 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
4326 if (TREE_CODE (ao
) == FUNCTION_DECL
)
4328 *pp_ti_abstract_origin (text
) = block
;
4331 block
= BLOCK_SUPERCONTEXT (block
);
4335 /* Print the identifier ID to PRETTY-PRINTER. */
4338 pp_tree_identifier (pretty_printer
*pp
, tree id
)
4340 if (pp_translate_identifiers (pp
))
4342 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
4343 pp_append_text (pp
, text
, text
+ strlen (text
));
4346 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
4347 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
4350 /* A helper function that is used to dump function information before the
4354 dump_function_header (FILE *dump_file
, tree fdecl
, dump_flags_t flags
)
4356 const char *dname
, *aname
;
4357 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
4358 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
4360 dname
= lang_hooks
.decl_printable_name (fdecl
, 1);
4362 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
4363 aname
= (IDENTIFIER_POINTER
4364 (DECL_ASSEMBLER_NAME (fdecl
)));
4366 aname
= "<unset-asm-name>";
4368 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
4369 dname
, aname
, fun
->funcdef_no
);
4370 if (!(flags
& TDF_NOUID
))
4371 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
4374 fprintf (dump_file
, ", cgraph_uid=%d", node
->get_uid ());
4375 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
4376 node
->frequency
== NODE_FREQUENCY_HOT
4378 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
4379 ? " (unlikely executed)"
4380 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
4381 ? " (executed once)"
4385 fprintf (dump_file
, ")\n\n");
4388 /* Dump double_int D to pretty_printer PP. UNS is true
4389 if D is unsigned and false otherwise. */
4391 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4394 pp_wide_integer (pp
, d
.low
);
4395 else if (d
.fits_uhwi ())
4396 pp_unsigned_wide_integer (pp
, d
.low
);
4399 unsigned HOST_WIDE_INT low
= d
.low
;
4400 HOST_WIDE_INT high
= d
.high
;
4401 if (!uns
&& d
.is_negative ())
4404 high
= ~high
+ !low
;
4407 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4409 sprintf (pp_buffer (pp
)->digit_buffer
,
4410 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4411 (unsigned HOST_WIDE_INT
) high
, low
);
4412 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
4417 # pragma GCC diagnostic pop