1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2015 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 /* Local functions, macros and variables. */
38 static const char *op_symbol (const_tree
);
39 static void pretty_print_string (pretty_printer
*, const char*);
40 static void newline_and_indent (pretty_printer
*, int);
41 static void maybe_init_pretty_print (FILE *);
42 static void print_struct_decl (pretty_printer
*, const_tree
, int, int);
43 static void do_niy (pretty_printer
*, const_tree
);
45 #define INDENT(SPACE) do { \
46 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
48 #define NIY do_niy (pp, node)
50 static pretty_printer
*tree_pp
;
52 /* Try to print something for an unknown tree code. */
55 do_niy (pretty_printer
*pp
, const_tree node
)
59 pp_string (pp
, "<<< Unknown tree: ");
60 pp_string (pp
, get_tree_code_name (TREE_CODE (node
)));
64 len
= TREE_OPERAND_LENGTH (node
);
65 for (i
= 0; i
< len
; ++i
)
67 newline_and_indent (pp
, 2);
68 dump_generic_node (pp
, TREE_OPERAND (node
, i
), 2, 0, false);
72 pp_string (pp
, " >>>");
75 /* Debugging function to print out a generic expression. */
78 debug_generic_expr (tree t
)
80 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
81 fprintf (stderr
, "\n");
84 /* Debugging function to print out a generic statement. */
87 debug_generic_stmt (tree t
)
89 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
90 fprintf (stderr
, "\n");
93 /* Debugging function to print out a chain of trees . */
96 debug_tree_chain (tree t
)
102 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
103 fprintf (stderr
, " ");
107 fprintf (stderr
, "... [cycled back to ");
108 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
109 fprintf (stderr
, "]");
113 fprintf (stderr
, "\n");
116 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
118 print_generic_decl (FILE *file
, tree decl
, int flags
)
120 maybe_init_pretty_print (file
);
121 print_declaration (tree_pp
, decl
, 2, flags
);
122 pp_write_text_to_stream (tree_pp
);
125 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
126 to show in the dump. See TDF_* in dumpfile.h. */
129 print_generic_stmt (FILE *file
, tree t
, int flags
)
131 maybe_init_pretty_print (file
);
132 dump_generic_node (tree_pp
, t
, 0, flags
, true);
133 pp_newline_and_flush (tree_pp
);
136 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
137 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
141 print_generic_stmt_indented (FILE *file
, tree t
, int flags
, int indent
)
145 maybe_init_pretty_print (file
);
147 for (i
= 0; i
< indent
; i
++)
149 dump_generic_node (tree_pp
, t
, indent
, flags
, true);
150 pp_newline_and_flush (tree_pp
);
153 /* Print a single expression T on file FILE. FLAGS specifies details to show
154 in the dump. See TDF_* in dumpfile.h. */
157 print_generic_expr (FILE *file
, tree t
, int flags
)
159 maybe_init_pretty_print (file
);
160 dump_generic_node (tree_pp
, t
, 0, flags
, false);
164 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
168 dump_decl_name (pretty_printer
*pp
, tree node
, int flags
)
170 if (DECL_NAME (node
))
172 if ((flags
& TDF_ASMNAME
) && DECL_ASSEMBLER_NAME_SET_P (node
))
173 pp_tree_identifier (pp
, DECL_ASSEMBLER_NAME (node
));
175 pp_tree_identifier (pp
, DECL_NAME (node
));
177 if ((flags
& TDF_UID
) || DECL_NAME (node
) == NULL_TREE
)
179 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
180 pp_printf (pp
, "L.%d", (int) LABEL_DECL_UID (node
));
181 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
183 if (flags
& TDF_NOUID
)
184 pp_string (pp
, "D#xxxx");
186 pp_printf (pp
, "D#%i", DEBUG_TEMP_UID (node
));
190 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
191 if (flags
& TDF_NOUID
)
192 pp_printf (pp
, "%c.xxxx", c
);
194 pp_printf (pp
, "%c.%u", c
, DECL_UID (node
));
197 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
199 if (flags
& TDF_NOUID
)
200 pp_printf (pp
, "ptD.xxxx");
202 pp_printf (pp
, "ptD.%u", DECL_PT_UID (node
));
206 /* Like the above, but used for pretty printing function calls. */
209 dump_function_name (pretty_printer
*pp
, tree node
, int flags
)
211 if (CONVERT_EXPR_P (node
))
212 node
= TREE_OPERAND (node
, 0);
213 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
214 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
216 dump_decl_name (pp
, node
, flags
);
219 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
220 FLAGS are as in dump_generic_node. */
223 dump_function_declaration (pretty_printer
*pp
, tree node
,
226 bool wrote_arg
= false;
232 /* Print the argument types. */
233 arg
= TYPE_ARG_TYPES (node
);
234 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
242 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
243 arg
= TREE_CHAIN (arg
);
246 /* Drop the trailing void_type_node if we had any previous argument. */
247 if (arg
== void_list_node
&& !wrote_arg
)
248 pp_string (pp
, "void");
249 /* Properly dump vararg function types. */
250 else if (!arg
&& wrote_arg
)
251 pp_string (pp
, ", ...");
252 /* Avoid printing any arg for unprototyped functions. */
257 /* Dump the domain associated with an array. */
260 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, int flags
)
262 pp_left_bracket (pp
);
265 tree min
= TYPE_MIN_VALUE (domain
);
266 tree max
= TYPE_MAX_VALUE (domain
);
269 && integer_zerop (min
)
270 && tree_fits_shwi_p (max
))
271 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
275 dump_generic_node (pp
, min
, spc
, flags
, false);
278 dump_generic_node (pp
, max
, spc
, flags
, false);
282 pp_string (pp
, "<unknown>");
283 pp_right_bracket (pp
);
287 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
288 dump_generic_node. */
291 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, int flags
)
295 switch (OMP_CLAUSE_CODE (clause
))
297 case OMP_CLAUSE_PRIVATE
:
300 case OMP_CLAUSE_SHARED
:
303 case OMP_CLAUSE_FIRSTPRIVATE
:
304 name
= "firstprivate";
306 case OMP_CLAUSE_LASTPRIVATE
:
307 name
= "lastprivate";
309 case OMP_CLAUSE_COPYIN
:
312 case OMP_CLAUSE_COPYPRIVATE
:
313 name
= "copyprivate";
315 case OMP_CLAUSE_UNIFORM
:
318 case OMP_CLAUSE_USE_DEVICE_PTR
:
319 name
= "use_device_ptr";
321 case OMP_CLAUSE_IS_DEVICE_PTR
:
322 name
= "is_device_ptr";
324 case OMP_CLAUSE__LOOPTEMP_
:
327 case OMP_CLAUSE_DEVICE_RESIDENT
:
328 name
= "device_resident";
330 case OMP_CLAUSE_USE_DEVICE
:
333 case OMP_CLAUSE_TO_DECLARE
:
336 case OMP_CLAUSE_LINK
:
340 pp_string (pp
, name
);
342 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
347 case OMP_CLAUSE_REDUCTION
:
348 pp_string (pp
, "reduction(");
349 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
352 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
355 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
361 pp_string (pp
, "if(");
362 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
364 case ERROR_MARK
: break;
365 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
366 case OMP_TASK
: pp_string (pp
, "task:"); break;
367 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
368 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
369 case OMP_TARGET
: pp_string (pp
, "target:"); break;
370 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
371 case OMP_TARGET_ENTER_DATA
:
372 pp_string (pp
, "target enter data:"); break;
373 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
374 default: gcc_unreachable ();
376 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
381 case OMP_CLAUSE_NUM_THREADS
:
382 pp_string (pp
, "num_threads(");
383 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
388 case OMP_CLAUSE__CILK_FOR_COUNT_
:
389 pp_string (pp
, "_Cilk_for_count_(");
390 dump_generic_node (pp
, OMP_CLAUSE_OPERAND (clause
, 0),
395 case OMP_CLAUSE_NOWAIT
:
396 pp_string (pp
, "nowait");
398 case OMP_CLAUSE_ORDERED
:
399 pp_string (pp
, "ordered");
400 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
403 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
409 case OMP_CLAUSE_DEFAULT
:
410 pp_string (pp
, "default(");
411 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
413 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
415 case OMP_CLAUSE_DEFAULT_SHARED
:
416 pp_string (pp
, "shared");
418 case OMP_CLAUSE_DEFAULT_NONE
:
419 pp_string (pp
, "none");
421 case OMP_CLAUSE_DEFAULT_PRIVATE
:
422 pp_string (pp
, "private");
424 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
425 pp_string (pp
, "firstprivate");
433 case OMP_CLAUSE_SCHEDULE
:
434 pp_string (pp
, "schedule(");
435 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
436 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
437 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
439 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
440 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
441 pp_string (pp
, "monotonic");
443 pp_string (pp
, "nonmonotonic");
444 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
449 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
450 pp_string (pp
, "simd:");
452 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
454 case OMP_CLAUSE_SCHEDULE_STATIC
:
455 pp_string (pp
, "static");
457 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
458 pp_string (pp
, "dynamic");
460 case OMP_CLAUSE_SCHEDULE_GUIDED
:
461 pp_string (pp
, "guided");
463 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
464 pp_string (pp
, "runtime");
466 case OMP_CLAUSE_SCHEDULE_AUTO
:
467 pp_string (pp
, "auto");
469 case OMP_CLAUSE_SCHEDULE_CILKFOR
:
470 pp_string (pp
, "cilk-for grain");
475 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
478 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
484 case OMP_CLAUSE_UNTIED
:
485 pp_string (pp
, "untied");
488 case OMP_CLAUSE_COLLAPSE
:
489 pp_string (pp
, "collapse(");
490 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
495 case OMP_CLAUSE_FINAL
:
496 pp_string (pp
, "final(");
497 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
502 case OMP_CLAUSE_MERGEABLE
:
503 pp_string (pp
, "mergeable");
506 case OMP_CLAUSE_LINEAR
:
507 pp_string (pp
, "linear(");
508 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
510 case OMP_CLAUSE_LINEAR_DEFAULT
:
512 case OMP_CLAUSE_LINEAR_REF
:
513 pp_string (pp
, "ref(");
515 case OMP_CLAUSE_LINEAR_VAL
:
516 pp_string (pp
, "val(");
518 case OMP_CLAUSE_LINEAR_UVAL
:
519 pp_string (pp
, "uval(");
524 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
526 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
529 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
534 case OMP_CLAUSE_ALIGNED
:
535 pp_string (pp
, "aligned(");
536 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
538 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
541 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
547 case OMP_CLAUSE_DEPEND
:
548 pp_string (pp
, "depend(");
549 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
551 case OMP_CLAUSE_DEPEND_IN
:
552 pp_string (pp
, "in");
554 case OMP_CLAUSE_DEPEND_OUT
:
555 pp_string (pp
, "out");
557 case OMP_CLAUSE_DEPEND_INOUT
:
558 pp_string (pp
, "inout");
560 case OMP_CLAUSE_DEPEND_SOURCE
:
561 pp_string (pp
, "source)");
563 case OMP_CLAUSE_DEPEND_SINK
:
564 pp_string (pp
, "sink:");
565 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
566 if (TREE_CODE (t
) == TREE_LIST
)
568 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
569 if (TREE_PURPOSE (t
) != integer_zero_node
)
571 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
575 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
589 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
595 pp_string (pp
, "map(");
596 switch (OMP_CLAUSE_MAP_KIND (clause
))
599 case GOMP_MAP_POINTER
:
600 pp_string (pp
, "alloc");
603 case GOMP_MAP_TO_PSET
:
604 pp_string (pp
, "to");
607 pp_string (pp
, "from");
609 case GOMP_MAP_TOFROM
:
610 pp_string (pp
, "tofrom");
612 case GOMP_MAP_FORCE_ALLOC
:
613 pp_string (pp
, "force_alloc");
615 case GOMP_MAP_FORCE_TO
:
616 pp_string (pp
, "force_to");
618 case GOMP_MAP_FORCE_FROM
:
619 pp_string (pp
, "force_from");
621 case GOMP_MAP_FORCE_TOFROM
:
622 pp_string (pp
, "force_tofrom");
624 case GOMP_MAP_FORCE_PRESENT
:
625 pp_string (pp
, "force_present");
627 case GOMP_MAP_FORCE_DEALLOC
:
628 pp_string (pp
, "delete");
630 case GOMP_MAP_FORCE_DEVICEPTR
:
631 pp_string (pp
, "force_deviceptr");
633 case GOMP_MAP_ALWAYS_TO
:
634 pp_string (pp
, "always,to");
636 case GOMP_MAP_ALWAYS_FROM
:
637 pp_string (pp
, "always,from");
639 case GOMP_MAP_ALWAYS_TOFROM
:
640 pp_string (pp
, "always,tofrom");
642 case GOMP_MAP_RELEASE
:
643 pp_string (pp
, "release");
645 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
646 pp_string (pp
, "firstprivate");
648 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
649 pp_string (pp
, "firstprivate ref");
651 case GOMP_MAP_STRUCT
:
652 pp_string (pp
, "struct");
654 case GOMP_MAP_ALWAYS_POINTER
:
655 pp_string (pp
, "always_pointer");
661 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
664 if (OMP_CLAUSE_SIZE (clause
))
666 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
667 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
669 case GOMP_MAP_POINTER
:
670 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
671 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
672 case GOMP_MAP_ALWAYS_POINTER
:
673 pp_string (pp
, " [pointer assign, bias: ");
675 case GOMP_MAP_TO_PSET
:
676 pp_string (pp
, " [pointer set, len: ");
679 pp_string (pp
, " [len: ");
682 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
684 pp_right_bracket (pp
);
689 case OMP_CLAUSE_FROM
:
690 pp_string (pp
, "from(");
691 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
693 goto print_clause_size
;
696 pp_string (pp
, "to(");
697 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
699 goto print_clause_size
;
701 case OMP_CLAUSE__CACHE_
:
703 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
705 goto print_clause_size
;
707 case OMP_CLAUSE_NUM_TEAMS
:
708 pp_string (pp
, "num_teams(");
709 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
714 case OMP_CLAUSE_THREAD_LIMIT
:
715 pp_string (pp
, "thread_limit(");
716 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
721 case OMP_CLAUSE_DEVICE
:
722 pp_string (pp
, "device(");
723 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
728 case OMP_CLAUSE_DIST_SCHEDULE
:
729 pp_string (pp
, "dist_schedule(static");
730 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
733 dump_generic_node (pp
,
734 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
740 case OMP_CLAUSE_PROC_BIND
:
741 pp_string (pp
, "proc_bind(");
742 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
744 case OMP_CLAUSE_PROC_BIND_MASTER
:
745 pp_string (pp
, "master");
747 case OMP_CLAUSE_PROC_BIND_CLOSE
:
748 pp_string (pp
, "close");
750 case OMP_CLAUSE_PROC_BIND_SPREAD
:
751 pp_string (pp
, "spread");
759 case OMP_CLAUSE_SAFELEN
:
760 pp_string (pp
, "safelen(");
761 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
766 case OMP_CLAUSE_SIMDLEN
:
767 pp_string (pp
, "simdlen(");
768 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
773 case OMP_CLAUSE_PRIORITY
:
774 pp_string (pp
, "priority(");
775 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
780 case OMP_CLAUSE_GRAINSIZE
:
781 pp_string (pp
, "grainsize(");
782 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
787 case OMP_CLAUSE_NUM_TASKS
:
788 pp_string (pp
, "num_tasks(");
789 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
794 case OMP_CLAUSE_HINT
:
795 pp_string (pp
, "hint(");
796 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
801 case OMP_CLAUSE_DEFAULTMAP
:
802 pp_string (pp
, "defaultmap(tofrom:scalar)");
805 case OMP_CLAUSE__SIMDUID_
:
806 pp_string (pp
, "_simduid_(");
807 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
812 case OMP_CLAUSE_GANG
:
813 pp_string (pp
, "gang");
814 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
816 pp_string (pp
, "(num: ");
817 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
820 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
822 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
826 pp_string (pp
, "static:");
827 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
828 == integer_minus_one_node
)
829 pp_character (pp
, '*');
831 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
834 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
835 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
839 case OMP_CLAUSE_ASYNC
:
840 pp_string (pp
, "async");
841 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
843 pp_character(pp
, '(');
844 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
846 pp_character(pp
, ')');
850 case OMP_CLAUSE_AUTO
:
852 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
855 case OMP_CLAUSE_WAIT
:
856 pp_string (pp
, "wait(");
857 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
859 pp_character(pp
, ')');
862 case OMP_CLAUSE_WORKER
:
863 pp_string (pp
, "worker");
864 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
867 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
873 case OMP_CLAUSE_VECTOR
:
874 pp_string (pp
, "vector");
875 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
878 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
884 case OMP_CLAUSE_NUM_GANGS
:
885 pp_string (pp
, "num_gangs(");
886 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
888 pp_character (pp
, ')');
891 case OMP_CLAUSE_NUM_WORKERS
:
892 pp_string (pp
, "num_workers(");
893 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
895 pp_character (pp
, ')');
898 case OMP_CLAUSE_VECTOR_LENGTH
:
899 pp_string (pp
, "vector_length(");
900 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
902 pp_character (pp
, ')');
905 case OMP_CLAUSE_INBRANCH
:
906 pp_string (pp
, "inbranch");
908 case OMP_CLAUSE_NOTINBRANCH
:
909 pp_string (pp
, "notinbranch");
912 pp_string (pp
, "for");
914 case OMP_CLAUSE_PARALLEL
:
915 pp_string (pp
, "parallel");
917 case OMP_CLAUSE_SECTIONS
:
918 pp_string (pp
, "sections");
920 case OMP_CLAUSE_TASKGROUP
:
921 pp_string (pp
, "taskgroup");
923 case OMP_CLAUSE_NOGROUP
:
924 pp_string (pp
, "nogroup");
926 case OMP_CLAUSE_THREADS
:
927 pp_string (pp
, "threads");
929 case OMP_CLAUSE_SIMD
:
930 pp_string (pp
, "simd");
932 case OMP_CLAUSE_INDEPENDENT
:
933 pp_string (pp
, "independent");
935 case OMP_CLAUSE_TILE
:
936 pp_string (pp
, "tile(");
937 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
943 /* Should never happen. */
944 dump_generic_node (pp
, clause
, spc
, flags
, false);
950 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
951 dump_generic_node. */
954 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, int flags
)
962 dump_omp_clause (pp
, clause
, spc
, flags
);
963 clause
= OMP_CLAUSE_CHAIN (clause
);
971 /* Dump location LOC to PP. */
974 dump_location (pretty_printer
*pp
, location_t loc
)
976 expanded_location xloc
= expand_location (loc
);
978 pp_left_bracket (pp
);
981 pp_string (pp
, xloc
.file
);
984 pp_decimal_int (pp
, xloc
.line
);
986 pp_decimal_int (pp
, xloc
.column
);
987 pp_string (pp
, "] ");
991 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
992 dump_generic_node. */
995 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, int flags
)
999 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1001 if (flags
& TDF_ADDRESS
)
1002 pp_printf (pp
, "[%p] ", (void *) block
);
1004 if (BLOCK_ABSTRACT (block
))
1005 pp_string (pp
, "[abstract] ");
1007 if (TREE_ASM_WRITTEN (block
))
1008 pp_string (pp
, "[written] ");
1010 if (flags
& TDF_SLIM
)
1013 if (BLOCK_SOURCE_LOCATION (block
))
1014 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1016 newline_and_indent (pp
, spc
+ 2);
1018 if (BLOCK_SUPERCONTEXT (block
))
1020 pp_string (pp
, "SUPERCONTEXT: ");
1021 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1022 flags
| TDF_SLIM
, false);
1023 newline_and_indent (pp
, spc
+ 2);
1026 if (BLOCK_SUBBLOCKS (block
))
1028 pp_string (pp
, "SUBBLOCKS: ");
1029 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1031 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1034 newline_and_indent (pp
, spc
+ 2);
1037 if (BLOCK_CHAIN (block
))
1039 pp_string (pp
, "SIBLINGS: ");
1040 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1042 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1045 newline_and_indent (pp
, spc
+ 2);
1048 if (BLOCK_VARS (block
))
1050 pp_string (pp
, "VARS: ");
1051 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1053 dump_generic_node (pp
, t
, 0, flags
, false);
1056 newline_and_indent (pp
, spc
+ 2);
1059 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1062 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1064 pp_string (pp
, "NONLOCALIZED_VARS: ");
1065 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1067 dump_generic_node (pp
, t
, 0, flags
, false);
1070 newline_and_indent (pp
, spc
+ 2);
1073 if (BLOCK_ABSTRACT_ORIGIN (block
))
1075 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1076 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1077 flags
| TDF_SLIM
, false);
1078 newline_and_indent (pp
, spc
+ 2);
1081 if (BLOCK_FRAGMENT_ORIGIN (block
))
1083 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1084 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1085 flags
| TDF_SLIM
, false);
1086 newline_and_indent (pp
, spc
+ 2);
1089 if (BLOCK_FRAGMENT_CHAIN (block
))
1091 pp_string (pp
, "FRAGMENT_CHAIN: ");
1092 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1094 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1097 newline_and_indent (pp
, spc
+ 2);
1102 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1103 indent. FLAGS specifies details to show in the dump (see TDF_* in
1104 dumpfile.h). If IS_STMT is true, the object printed is considered
1105 to be a statement and it is terminated by ';' if appropriate. */
1108 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, int flags
,
1115 enum tree_code code
;
1117 if (node
== NULL_TREE
)
1120 is_expr
= EXPR_P (node
);
1122 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1123 pp_printf (pp
, "<&%p> ", (void *)node
);
1125 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1126 dump_location (pp
, EXPR_LOCATION (node
));
1128 code
= TREE_CODE (node
);
1132 pp_string (pp
, "<<< error >>>");
1135 case IDENTIFIER_NODE
:
1136 pp_tree_identifier (pp
, node
);
1140 while (node
&& node
!= error_mark_node
)
1142 if (TREE_PURPOSE (node
))
1144 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1147 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1148 node
= TREE_CHAIN (node
);
1149 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1158 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1164 if (TREE_VEC_LENGTH (node
) > 0)
1166 size_t len
= TREE_VEC_LENGTH (node
);
1167 for (i
= 0; i
< len
- 1; i
++)
1169 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1174 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1181 case POINTER_BOUNDS_TYPE
:
1184 case FIXED_POINT_TYPE
:
1190 unsigned int quals
= TYPE_QUALS (node
);
1191 enum tree_code_class tclass
;
1193 if (quals
& TYPE_QUAL_ATOMIC
)
1194 pp_string (pp
, "atomic ");
1195 if (quals
& TYPE_QUAL_CONST
)
1196 pp_string (pp
, "const ");
1197 else if (quals
& TYPE_QUAL_VOLATILE
)
1198 pp_string (pp
, "volatile ");
1199 else if (quals
& TYPE_QUAL_RESTRICT
)
1200 pp_string (pp
, "restrict ");
1202 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1204 pp_string (pp
, "<address-space-");
1205 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1206 pp_string (pp
, "> ");
1209 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1211 if (tclass
== tcc_declaration
)
1213 if (DECL_NAME (node
))
1214 dump_decl_name (pp
, node
, flags
);
1216 pp_string (pp
, "<unnamed type decl>");
1218 else if (tclass
== tcc_type
)
1220 if (TYPE_NAME (node
))
1222 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1223 pp_tree_identifier (pp
, TYPE_NAME (node
));
1224 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1225 && DECL_NAME (TYPE_NAME (node
)))
1226 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1228 pp_string (pp
, "<unnamed type>");
1230 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1232 pp_string (pp
, "vector");
1234 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1235 pp_string (pp
, ") ");
1236 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1238 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1240 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1241 pp_string (pp
, (TYPE_UNSIGNED (node
)
1244 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1245 pp_string (pp
, (TYPE_UNSIGNED (node
)
1248 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1249 pp_string (pp
, (TYPE_UNSIGNED (node
)
1252 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1253 pp_string (pp
, (TYPE_UNSIGNED (node
)
1256 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1257 pp_string (pp
, (TYPE_UNSIGNED (node
)
1258 ? "unsigned long long"
1259 : "signed long long"));
1260 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1261 && exact_log2 (TYPE_PRECISION (node
)) != -1)
1263 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1264 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1265 pp_string (pp
, "_t");
1269 pp_string (pp
, (TYPE_UNSIGNED (node
)
1270 ? "<unnamed-unsigned:"
1271 : "<unnamed-signed:"));
1272 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1276 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1278 pp_string (pp
, "__complex__ ");
1279 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1281 else if (TREE_CODE (node
) == REAL_TYPE
)
1283 pp_string (pp
, "<float:");
1284 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1287 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1289 pp_string (pp
, "<fixed-point-");
1290 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1291 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1294 else if (TREE_CODE (node
) == VOID_TYPE
)
1295 pp_string (pp
, "void");
1297 pp_string (pp
, "<unnamed type>");
1303 case REFERENCE_TYPE
:
1304 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1306 if (TREE_TYPE (node
) == NULL
)
1308 pp_string (pp
, str
);
1309 pp_string (pp
, "<null type>");
1311 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1313 tree fnode
= TREE_TYPE (node
);
1315 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1318 pp_string (pp
, str
);
1319 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1320 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1321 else if (flags
& TDF_NOUID
)
1322 pp_printf (pp
, "<Txxxx>");
1324 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1326 pp_right_paren (pp
);
1327 dump_function_declaration (pp
, fnode
, spc
, flags
);
1331 unsigned int quals
= TYPE_QUALS (node
);
1333 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1335 pp_string (pp
, str
);
1337 if (quals
& TYPE_QUAL_CONST
)
1338 pp_string (pp
, " const");
1339 if (quals
& TYPE_QUAL_VOLATILE
)
1340 pp_string (pp
, " volatile");
1341 if (quals
& TYPE_QUAL_RESTRICT
)
1342 pp_string (pp
, " restrict");
1344 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1346 pp_string (pp
, " <address-space-");
1347 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1351 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1352 pp_string (pp
, " {ref-all}");
1362 if (integer_zerop (TREE_OPERAND (node
, 1))
1363 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1364 infer them and MEM_ATTR caching will share MEM_REFs
1365 with differently-typed op0s. */
1366 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1367 /* Released SSA_NAMES have no TREE_TYPE. */
1368 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1369 /* Same pointer types, but ignoring POINTER_TYPE vs.
1371 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1372 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1373 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1374 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1375 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1376 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1377 /* Same value types ignoring qualifiers. */
1378 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1379 == TYPE_MAIN_VARIANT
1380 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1381 && (!(flags
& TDF_ALIAS
)
1382 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1384 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1387 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1391 dump_generic_node (pp
,
1392 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1399 pp_string (pp
, "MEM[");
1401 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1402 dump_generic_node (pp
, ptype
,
1403 spc
, flags
| TDF_SLIM
, false);
1404 pp_right_paren (pp
);
1405 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1407 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1409 pp_string (pp
, " + ");
1410 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1413 if ((flags
& TDF_ALIAS
)
1414 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1416 pp_string (pp
, " clique ");
1417 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1418 pp_string (pp
, " base ");
1419 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1421 pp_right_bracket (pp
);
1426 case TARGET_MEM_REF
:
1428 const char *sep
= "";
1431 pp_string (pp
, "MEM[");
1433 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1435 pp_string (pp
, sep
);
1437 pp_string (pp
, "symbol: ");
1438 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1443 pp_string (pp
, sep
);
1445 pp_string (pp
, "base: ");
1446 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1448 tmp
= TMR_INDEX2 (node
);
1451 pp_string (pp
, sep
);
1453 pp_string (pp
, "base: ");
1454 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1456 tmp
= TMR_INDEX (node
);
1459 pp_string (pp
, sep
);
1461 pp_string (pp
, "index: ");
1462 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1464 tmp
= TMR_STEP (node
);
1467 pp_string (pp
, sep
);
1469 pp_string (pp
, "step: ");
1470 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1472 tmp
= TMR_OFFSET (node
);
1475 pp_string (pp
, sep
);
1477 pp_string (pp
, "offset: ");
1478 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1480 pp_right_bracket (pp
);
1488 /* Print the innermost component type. */
1489 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1490 tmp
= TREE_TYPE (tmp
))
1492 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1494 /* Print the dimensions. */
1495 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1496 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1502 case QUAL_UNION_TYPE
:
1504 unsigned int quals
= TYPE_QUALS (node
);
1506 if (quals
& TYPE_QUAL_ATOMIC
)
1507 pp_string (pp
, "atomic ");
1508 if (quals
& TYPE_QUAL_CONST
)
1509 pp_string (pp
, "const ");
1510 if (quals
& TYPE_QUAL_VOLATILE
)
1511 pp_string (pp
, "volatile ");
1513 /* Print the name of the structure. */
1514 if (TREE_CODE (node
) == RECORD_TYPE
)
1515 pp_string (pp
, "struct ");
1516 else if (TREE_CODE (node
) == UNION_TYPE
)
1517 pp_string (pp
, "union ");
1519 if (TYPE_NAME (node
))
1520 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1521 else if (!(flags
& TDF_SLIM
))
1522 /* FIXME: If we eliminate the 'else' above and attempt
1523 to show the fields for named types, we may get stuck
1524 following a cycle of pointers to structs. The alleged
1525 self-reference check in print_struct_decl will not detect
1526 cycles involving more than one pointer or struct type. */
1527 print_struct_decl (pp
, node
, spc
, flags
);
1536 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
1538 /* In the case of a pointer, one may want to divide by the
1539 size of the pointed-to type. Unfortunately, this not
1540 straightforward. The C front-end maps expressions
1545 in such a way that the two INTEGER_CST nodes for "5" have
1546 different values but identical types. In the latter
1547 case, the 5 is multiplied by sizeof (int) in c-common.c
1548 (pointer_int_sum) to convert it to a byte address, and
1549 yet the type of the node is left unchanged. Argh. What
1550 is consistent though is that the number value corresponds
1551 to bytes (UNITS) offset.
1553 NB: Neither of the following divisors can be trivially
1554 used to recover the original literal:
1556 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1557 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1558 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1559 pp_string (pp
, "B"); /* pseudo-unit */
1561 else if (tree_fits_shwi_p (node
))
1562 pp_wide_integer (pp
, tree_to_shwi (node
));
1563 else if (tree_fits_uhwi_p (node
))
1564 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1567 wide_int val
= node
;
1569 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1574 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
1575 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
1577 if (TREE_OVERFLOW (node
))
1578 pp_string (pp
, "(OVF)");
1582 /* Code copied from print_node. */
1585 if (TREE_OVERFLOW (node
))
1586 pp_string (pp
, " overflow");
1588 d
= TREE_REAL_CST (node
);
1589 if (REAL_VALUE_ISINF (d
))
1590 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1591 else if (REAL_VALUE_ISNAN (d
))
1592 pp_string (pp
, " Nan");
1596 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1597 pp_string (pp
, string
);
1605 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1606 pp_string (pp
, string
);
1611 pp_string (pp
, "__complex__ (");
1612 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
1613 pp_string (pp
, ", ");
1614 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
1615 pp_right_paren (pp
);
1619 pp_string (pp
, "\"");
1620 pretty_print_string (pp
, TREE_STRING_POINTER (node
));
1621 pp_string (pp
, "\"");
1627 pp_string (pp
, "{ ");
1628 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1631 pp_string (pp
, ", ");
1632 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
1635 pp_string (pp
, " }");
1641 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1643 if (TREE_CODE (node
) == METHOD_TYPE
)
1645 if (TYPE_METHOD_BASETYPE (node
))
1646 dump_decl_name (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1649 pp_string (pp
, "<null method basetype>");
1650 pp_colon_colon (pp
);
1652 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1653 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1654 else if (flags
& TDF_NOUID
)
1655 pp_printf (pp
, "<Txxxx>");
1657 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1658 dump_function_declaration (pp
, node
, spc
, flags
);
1663 dump_decl_name (pp
, node
, flags
);
1667 if (DECL_NAME (node
))
1668 dump_decl_name (pp
, node
, flags
);
1669 else if (LABEL_DECL_UID (node
) != -1)
1670 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
1673 if (flags
& TDF_NOUID
)
1674 pp_string (pp
, "<D.xxxx>");
1676 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
1681 if (DECL_IS_BUILTIN (node
))
1683 /* Don't print the declaration of built-in types. */
1686 if (DECL_NAME (node
))
1687 dump_decl_name (pp
, node
, flags
);
1688 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1690 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1691 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1692 && TYPE_METHODS (TREE_TYPE (node
)))
1694 /* The type is a c++ class: all structures have at least
1696 pp_string (pp
, "class ");
1697 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1702 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1703 ? "union" : "struct "));
1704 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1708 pp_string (pp
, "<anon>");
1714 case DEBUG_EXPR_DECL
:
1715 case NAMESPACE_DECL
:
1717 dump_decl_name (pp
, node
, flags
);
1721 pp_string (pp
, "<retval>");
1725 op0
= TREE_OPERAND (node
, 0);
1728 && (TREE_CODE (op0
) == INDIRECT_REF
1729 || (TREE_CODE (op0
) == MEM_REF
1730 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1731 && integer_zerop (TREE_OPERAND (op0
, 1))
1732 /* Dump the types of INTEGER_CSTs explicitly, for we
1733 can't infer them and MEM_ATTR caching will share
1734 MEM_REFs with differently-typed op0s. */
1735 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1736 /* Released SSA_NAMES have no TREE_TYPE. */
1737 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1738 /* Same pointer types, but ignoring POINTER_TYPE vs.
1740 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1741 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1742 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1743 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1744 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1745 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1746 /* Same value types ignoring qualifiers. */
1747 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1748 == TYPE_MAIN_VARIANT
1749 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
1750 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
1752 op0
= TREE_OPERAND (op0
, 0);
1755 if (op_prio (op0
) < op_prio (node
))
1757 dump_generic_node (pp
, op0
, spc
, flags
, false);
1758 if (op_prio (op0
) < op_prio (node
))
1759 pp_right_paren (pp
);
1760 pp_string (pp
, str
);
1761 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1762 op0
= component_ref_field_offset (node
);
1763 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1765 pp_string (pp
, "{off: ");
1766 dump_generic_node (pp
, op0
, spc
, flags
, false);
1767 pp_right_brace (pp
);
1772 pp_string (pp
, "BIT_FIELD_REF <");
1773 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1774 pp_string (pp
, ", ");
1775 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1776 pp_string (pp
, ", ");
1777 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1782 case ARRAY_RANGE_REF
:
1783 op0
= TREE_OPERAND (node
, 0);
1784 if (op_prio (op0
) < op_prio (node
))
1786 dump_generic_node (pp
, op0
, spc
, flags
, false);
1787 if (op_prio (op0
) < op_prio (node
))
1788 pp_right_paren (pp
);
1789 pp_left_bracket (pp
);
1790 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1791 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1792 pp_string (pp
, " ...");
1793 pp_right_bracket (pp
);
1795 op0
= array_ref_low_bound (node
);
1796 op1
= array_ref_element_size (node
);
1798 if (!integer_zerop (op0
)
1799 || TREE_OPERAND (node
, 2)
1800 || TREE_OPERAND (node
, 3))
1802 pp_string (pp
, "{lb: ");
1803 dump_generic_node (pp
, op0
, spc
, flags
, false);
1804 pp_string (pp
, " sz: ");
1805 dump_generic_node (pp
, op1
, spc
, flags
, false);
1806 pp_right_brace (pp
);
1812 unsigned HOST_WIDE_INT ix
;
1814 bool is_struct_init
= false;
1815 bool is_array_init
= false;
1818 if (TREE_CLOBBER_P (node
))
1819 pp_string (pp
, "CLOBBER");
1820 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1821 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1822 is_struct_init
= true;
1823 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
1824 && TYPE_DOMAIN (TREE_TYPE (node
))
1825 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
1826 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
1829 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
1830 is_array_init
= true;
1831 curidx
= wi::to_widest (minv
);
1833 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1840 dump_generic_node (pp
, field
, spc
, flags
, false);
1843 else if (is_array_init
1844 && (TREE_CODE (field
) != INTEGER_CST
1845 || curidx
!= wi::to_widest (field
)))
1847 pp_left_bracket (pp
);
1848 if (TREE_CODE (field
) == RANGE_EXPR
)
1850 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
1852 pp_string (pp
, " ... ");
1853 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
1855 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
1856 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
1859 dump_generic_node (pp
, field
, spc
, flags
, false);
1860 if (TREE_CODE (field
) == INTEGER_CST
)
1861 curidx
= wi::to_widest (field
);
1862 pp_string (pp
, "]=");
1867 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1868 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1869 val
= TREE_OPERAND (val
, 0);
1870 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1871 dump_decl_name (pp
, val
, flags
);
1873 dump_generic_node (pp
, val
, spc
, flags
, false);
1874 if (ix
!= vec_safe_length (CONSTRUCTOR_ELTS (node
)) - 1)
1880 pp_right_brace (pp
);
1887 if (flags
& TDF_SLIM
)
1889 pp_string (pp
, "<COMPOUND_EXPR>");
1893 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1894 spc
, flags
, !(flags
& TDF_SLIM
));
1895 if (flags
& TDF_SLIM
)
1896 newline_and_indent (pp
, spc
);
1903 for (tp
= &TREE_OPERAND (node
, 1);
1904 TREE_CODE (*tp
) == COMPOUND_EXPR
;
1905 tp
= &TREE_OPERAND (*tp
, 1))
1907 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
1908 spc
, flags
, !(flags
& TDF_SLIM
));
1909 if (flags
& TDF_SLIM
)
1910 newline_and_indent (pp
, spc
);
1918 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
1922 case STATEMENT_LIST
:
1924 tree_stmt_iterator si
;
1927 if (flags
& TDF_SLIM
)
1929 pp_string (pp
, "<STATEMENT_LIST>");
1933 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
1936 newline_and_indent (pp
, spc
);
1939 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
1946 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
1951 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
1956 pp_string (pp
, "TARGET_EXPR <");
1957 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
1960 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
1965 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
1970 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
1972 pp_string (pp
, "if (");
1973 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
1974 pp_right_paren (pp
);
1975 /* The lowered cond_exprs should always be printed in full. */
1976 if (COND_EXPR_THEN (node
)
1977 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
1978 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
1979 && COND_EXPR_ELSE (node
)
1980 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
1981 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
1984 dump_generic_node (pp
, COND_EXPR_THEN (node
),
1986 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1988 pp_string (pp
, " else ");
1989 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
1993 else if (!(flags
& TDF_SLIM
))
1995 /* Output COND_EXPR_THEN. */
1996 if (COND_EXPR_THEN (node
))
1998 newline_and_indent (pp
, spc
+2);
2000 newline_and_indent (pp
, spc
+4);
2001 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2003 newline_and_indent (pp
, spc
+2);
2004 pp_right_brace (pp
);
2007 /* Output COND_EXPR_ELSE. */
2008 if (COND_EXPR_ELSE (node
)
2009 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2011 newline_and_indent (pp
, spc
);
2012 pp_string (pp
, "else");
2013 newline_and_indent (pp
, spc
+2);
2015 newline_and_indent (pp
, spc
+4);
2016 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2018 newline_and_indent (pp
, spc
+2);
2019 pp_right_brace (pp
);
2026 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2030 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2034 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2040 if (!(flags
& TDF_SLIM
))
2042 if (BIND_EXPR_VARS (node
))
2046 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2048 print_declaration (pp
, op0
, spc
+2, flags
);
2053 newline_and_indent (pp
, spc
+2);
2054 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2055 newline_and_indent (pp
, spc
);
2056 pp_right_brace (pp
);
2062 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2063 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2065 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2067 /* Print parameters. */
2072 call_expr_arg_iterator iter
;
2073 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2075 dump_generic_node (pp
, arg
, spc
, flags
, false);
2076 if (more_call_expr_args_p (&iter
))
2083 if (CALL_EXPR_VA_ARG_PACK (node
))
2085 if (call_expr_nargs (node
) > 0)
2090 pp_string (pp
, "__builtin_va_arg_pack ()");
2092 pp_right_paren (pp
);
2094 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2097 pp_string (pp
, " [static-chain: ");
2098 dump_generic_node (pp
, op1
, spc
, flags
, false);
2099 pp_right_bracket (pp
);
2102 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2103 pp_string (pp
, " [return slot optimization]");
2104 if (CALL_EXPR_TAILCALL (node
))
2105 pp_string (pp
, " [tail call]");
2108 case WITH_CLEANUP_EXPR
:
2112 case CLEANUP_POINT_EXPR
:
2113 pp_string (pp
, "<<cleanup_point ");
2114 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2115 pp_string (pp
, ">>");
2118 case PLACEHOLDER_EXPR
:
2119 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2120 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2124 /* Binary arithmetic and logic expressions. */
2125 case WIDEN_SUM_EXPR
:
2126 case WIDEN_MULT_EXPR
:
2128 case MULT_HIGHPART_EXPR
:
2130 case POINTER_PLUS_EXPR
:
2132 case TRUNC_DIV_EXPR
:
2134 case FLOOR_DIV_EXPR
:
2135 case ROUND_DIV_EXPR
:
2136 case TRUNC_MOD_EXPR
:
2138 case FLOOR_MOD_EXPR
:
2139 case ROUND_MOD_EXPR
:
2141 case EXACT_DIV_EXPR
:
2146 case WIDEN_LSHIFT_EXPR
:
2150 case TRUTH_ANDIF_EXPR
:
2151 case TRUTH_ORIF_EXPR
:
2152 case TRUTH_AND_EXPR
:
2154 case TRUTH_XOR_EXPR
:
2168 case UNORDERED_EXPR
:
2170 const char *op
= op_symbol (node
);
2171 op0
= TREE_OPERAND (node
, 0);
2172 op1
= TREE_OPERAND (node
, 1);
2174 /* When the operands are expressions with less priority,
2175 keep semantics of the tree representation. */
2176 if (op_prio (op0
) <= op_prio (node
))
2179 dump_generic_node (pp
, op0
, spc
, flags
, false);
2180 pp_right_paren (pp
);
2183 dump_generic_node (pp
, op0
, spc
, flags
, false);
2189 /* When the operands are expressions with less priority,
2190 keep semantics of the tree representation. */
2191 if (op_prio (op1
) <= op_prio (node
))
2194 dump_generic_node (pp
, op1
, spc
, flags
, false);
2195 pp_right_paren (pp
);
2198 dump_generic_node (pp
, op1
, spc
, flags
, false);
2202 /* Unary arithmetic and logic expressions. */
2205 case TRUTH_NOT_EXPR
:
2207 case PREDECREMENT_EXPR
:
2208 case PREINCREMENT_EXPR
:
2210 if (TREE_CODE (node
) == ADDR_EXPR
2211 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2212 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2213 ; /* Do not output '&' for strings and function pointers. */
2215 pp_string (pp
, op_symbol (node
));
2217 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2220 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2221 pp_right_paren (pp
);
2224 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2227 case POSTDECREMENT_EXPR
:
2228 case POSTINCREMENT_EXPR
:
2229 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2232 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2233 pp_right_paren (pp
);
2236 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2237 pp_string (pp
, op_symbol (node
));
2241 pp_string (pp
, "MIN_EXPR <");
2242 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2243 pp_string (pp
, ", ");
2244 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2249 pp_string (pp
, "MAX_EXPR <");
2250 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2251 pp_string (pp
, ", ");
2252 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2257 pp_string (pp
, "ABS_EXPR <");
2258 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2266 case ADDR_SPACE_CONVERT_EXPR
:
2267 case FIXED_CONVERT_EXPR
:
2268 case FIX_TRUNC_EXPR
:
2271 type
= TREE_TYPE (node
);
2272 op0
= TREE_OPERAND (node
, 0);
2273 if (type
!= TREE_TYPE (op0
))
2276 dump_generic_node (pp
, type
, spc
, flags
, false);
2277 pp_string (pp
, ") ");
2279 if (op_prio (op0
) < op_prio (node
))
2281 dump_generic_node (pp
, op0
, spc
, flags
, false);
2282 if (op_prio (op0
) < op_prio (node
))
2283 pp_right_paren (pp
);
2286 case VIEW_CONVERT_EXPR
:
2287 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2288 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2289 pp_string (pp
, ">(");
2290 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2291 pp_right_paren (pp
);
2295 pp_string (pp
, "((");
2296 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2297 pp_string (pp
, "))");
2300 case NON_LVALUE_EXPR
:
2301 pp_string (pp
, "NON_LVALUE_EXPR <");
2302 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2307 pp_string (pp
, "SAVE_EXPR <");
2308 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2313 pp_string (pp
, "COMPLEX_EXPR <");
2314 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2315 pp_string (pp
, ", ");
2316 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2321 pp_string (pp
, "CONJ_EXPR <");
2322 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2327 pp_string (pp
, "REALPART_EXPR <");
2328 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2333 pp_string (pp
, "IMAGPART_EXPR <");
2334 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2339 pp_string (pp
, "VA_ARG_EXPR <");
2340 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2344 case TRY_FINALLY_EXPR
:
2345 case TRY_CATCH_EXPR
:
2346 pp_string (pp
, "try");
2347 newline_and_indent (pp
, spc
+2);
2349 newline_and_indent (pp
, spc
+4);
2350 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2351 newline_and_indent (pp
, spc
+2);
2352 pp_right_brace (pp
);
2353 newline_and_indent (pp
, spc
);
2355 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2356 newline_and_indent (pp
, spc
+2);
2358 newline_and_indent (pp
, spc
+4);
2359 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2360 newline_and_indent (pp
, spc
+2);
2361 pp_right_brace (pp
);
2366 pp_string (pp
, "catch (");
2367 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2368 pp_right_paren (pp
);
2369 newline_and_indent (pp
, spc
+2);
2371 newline_and_indent (pp
, spc
+4);
2372 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2373 newline_and_indent (pp
, spc
+2);
2374 pp_right_brace (pp
);
2378 case EH_FILTER_EXPR
:
2379 pp_string (pp
, "<<<eh_filter (");
2380 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2381 pp_string (pp
, ")>>>");
2382 newline_and_indent (pp
, spc
+2);
2384 newline_and_indent (pp
, spc
+4);
2385 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2386 newline_and_indent (pp
, spc
+2);
2387 pp_right_brace (pp
);
2392 op0
= TREE_OPERAND (node
, 0);
2393 /* If this is for break or continue, don't bother printing it. */
2394 if (DECL_NAME (op0
))
2396 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2397 if (strcmp (name
, "break") == 0
2398 || strcmp (name
, "continue") == 0)
2401 dump_generic_node (pp
, op0
, spc
, flags
, false);
2403 if (DECL_NONLOCAL (op0
))
2404 pp_string (pp
, " [non-local]");
2408 pp_string (pp
, "while (1)");
2409 if (!(flags
& TDF_SLIM
))
2411 newline_and_indent (pp
, spc
+2);
2413 newline_and_indent (pp
, spc
+4);
2414 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2415 newline_and_indent (pp
, spc
+2);
2416 pp_right_brace (pp
);
2422 pp_string (pp
, "// predicted ");
2423 if (PREDICT_EXPR_OUTCOME (node
))
2424 pp_string (pp
, "likely by ");
2426 pp_string (pp
, "unlikely by ");
2427 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2428 pp_string (pp
, " predictor.");
2432 pp_string (pp
, "ANNOTATE_EXPR <");
2433 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2434 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2436 case annot_expr_ivdep_kind
:
2437 pp_string (pp
, ", ivdep");
2439 case annot_expr_no_vector_kind
:
2440 pp_string (pp
, ", no-vector");
2442 case annot_expr_vector_kind
:
2443 pp_string (pp
, ", vector");
2452 pp_string (pp
, "return");
2453 op0
= TREE_OPERAND (node
, 0);
2457 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2458 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2461 dump_generic_node (pp
, op0
, spc
, flags
, false);
2466 pp_string (pp
, "if (");
2467 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2468 pp_string (pp
, ") break");
2472 pp_string (pp
, "switch (");
2473 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2474 pp_right_paren (pp
);
2475 if (!(flags
& TDF_SLIM
))
2477 newline_and_indent (pp
, spc
+2);
2479 if (SWITCH_BODY (node
))
2481 newline_and_indent (pp
, spc
+4);
2482 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2487 tree vec
= SWITCH_LABELS (node
);
2488 size_t i
, n
= TREE_VEC_LENGTH (vec
);
2489 for (i
= 0; i
< n
; ++i
)
2491 tree elt
= TREE_VEC_ELT (vec
, i
);
2492 newline_and_indent (pp
, spc
+4);
2495 dump_generic_node (pp
, elt
, spc
+4, flags
, false);
2496 pp_string (pp
, " goto ");
2497 dump_generic_node (pp
, CASE_LABEL (elt
), spc
+4,
2502 pp_string (pp
, "case ???: goto ???;");
2505 newline_and_indent (pp
, spc
+2);
2506 pp_right_brace (pp
);
2512 op0
= GOTO_DESTINATION (node
);
2513 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2515 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2516 if (strcmp (name
, "break") == 0
2517 || strcmp (name
, "continue") == 0)
2519 pp_string (pp
, name
);
2523 pp_string (pp
, "goto ");
2524 dump_generic_node (pp
, op0
, spc
, flags
, false);
2528 pp_string (pp
, "__asm__");
2529 if (ASM_VOLATILE_P (node
))
2530 pp_string (pp
, " __volatile__");
2532 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2534 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2536 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2537 if (ASM_CLOBBERS (node
))
2540 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2542 pp_right_paren (pp
);
2545 case CASE_LABEL_EXPR
:
2546 if (CASE_LOW (node
) && CASE_HIGH (node
))
2548 pp_string (pp
, "case ");
2549 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2550 pp_string (pp
, " ... ");
2551 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2553 else if (CASE_LOW (node
))
2555 pp_string (pp
, "case ");
2556 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2559 pp_string (pp
, "default");
2564 pp_string (pp
, "OBJ_TYPE_REF(");
2565 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2567 if (!(flags
& TDF_SLIM
) && virtual_method_call_p (node
))
2569 pp_string (pp
, "(");
2570 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2571 pp_string (pp
, ")");
2573 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2575 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2576 pp_right_paren (pp
);
2580 if (SSA_NAME_IDENTIFIER (node
))
2581 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2584 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2585 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2586 pp_string (pp
, "(D)");
2587 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2588 pp_string (pp
, "(ab)");
2591 case WITH_SIZE_EXPR
:
2592 pp_string (pp
, "WITH_SIZE_EXPR <");
2593 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2594 pp_string (pp
, ", ");
2595 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2600 pp_string (pp
, "ASSERT_EXPR <");
2601 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2602 pp_string (pp
, ", ");
2603 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2608 pp_string (pp
, "scev_known");
2611 case SCEV_NOT_KNOWN
:
2612 pp_string (pp
, "scev_not_known");
2615 case POLYNOMIAL_CHREC
:
2617 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2618 pp_string (pp
, ", +, ");
2619 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2620 pp_string (pp
, "}_");
2621 dump_generic_node (pp
, CHREC_VAR (node
), spc
, flags
, false);
2625 case REALIGN_LOAD_EXPR
:
2626 pp_string (pp
, "REALIGN_LOAD <");
2627 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2628 pp_string (pp
, ", ");
2629 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2630 pp_string (pp
, ", ");
2631 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2636 pp_string (pp
, " VEC_COND_EXPR < ");
2637 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2638 pp_string (pp
, " , ");
2639 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2640 pp_string (pp
, " , ");
2641 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2642 pp_string (pp
, " > ");
2646 pp_string (pp
, " VEC_PERM_EXPR < ");
2647 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2648 pp_string (pp
, " , ");
2649 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2650 pp_string (pp
, " , ");
2651 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2652 pp_string (pp
, " > ");
2656 pp_string (pp
, " DOT_PROD_EXPR < ");
2657 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2658 pp_string (pp
, ", ");
2659 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2660 pp_string (pp
, ", ");
2661 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2662 pp_string (pp
, " > ");
2665 case WIDEN_MULT_PLUS_EXPR
:
2666 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
2667 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2668 pp_string (pp
, ", ");
2669 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2670 pp_string (pp
, ", ");
2671 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2672 pp_string (pp
, " > ");
2675 case WIDEN_MULT_MINUS_EXPR
:
2676 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
2677 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2678 pp_string (pp
, ", ");
2679 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2680 pp_string (pp
, ", ");
2681 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2682 pp_string (pp
, " > ");
2686 pp_string (pp
, " FMA_EXPR < ");
2687 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2688 pp_string (pp
, ", ");
2689 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2690 pp_string (pp
, ", ");
2691 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2692 pp_string (pp
, " > ");
2696 pp_string (pp
, "#pragma acc parallel");
2697 goto dump_omp_clauses_body
;
2700 pp_string (pp
, "#pragma acc kernels");
2701 goto dump_omp_clauses_body
;
2704 pp_string (pp
, "#pragma acc data");
2705 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2708 case OACC_HOST_DATA
:
2709 pp_string (pp
, "#pragma acc host_data");
2710 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2714 pp_string (pp
, "#pragma acc declare");
2715 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2719 pp_string (pp
, "#pragma acc update");
2720 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2723 case OACC_ENTER_DATA
:
2724 pp_string (pp
, "#pragma acc enter data");
2725 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2728 case OACC_EXIT_DATA
:
2729 pp_string (pp
, "#pragma acc exit data");
2730 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2734 pp_string (pp
, "#pragma acc cache");
2735 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2739 pp_string (pp
, "#pragma omp parallel");
2740 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2743 dump_omp_clauses_body
:
2744 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2748 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2750 newline_and_indent (pp
, spc
+ 2);
2752 newline_and_indent (pp
, spc
+ 4);
2753 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2754 newline_and_indent (pp
, spc
+ 2);
2755 pp_right_brace (pp
);
2761 pp_string (pp
, "#pragma omp task");
2762 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2766 pp_string (pp
, "#pragma omp for");
2770 pp_string (pp
, "#pragma omp simd");
2774 pp_string (pp
, "#pragma simd");
2778 /* This label points one line after dumping the clauses.
2779 For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2780 parameters are printed out. */
2781 goto dump_omp_loop_cilk_for
;
2783 case OMP_DISTRIBUTE
:
2784 pp_string (pp
, "#pragma omp distribute");
2788 pp_string (pp
, "#pragma omp taskloop");
2792 pp_string (pp
, "#pragma acc loop");
2796 pp_string (pp
, "#pragma omp teams");
2797 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
2800 case OMP_TARGET_DATA
:
2801 pp_string (pp
, "#pragma omp target data");
2802 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
2805 case OMP_TARGET_ENTER_DATA
:
2806 pp_string (pp
, "#pragma omp target enter data");
2807 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2811 case OMP_TARGET_EXIT_DATA
:
2812 pp_string (pp
, "#pragma omp target exit data");
2813 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2818 pp_string (pp
, "#pragma omp target");
2819 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
2822 case OMP_TARGET_UPDATE
:
2823 pp_string (pp
, "#pragma omp target update");
2824 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
2829 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2831 dump_omp_loop_cilk_for
:
2832 if (!(flags
& TDF_SLIM
))
2836 if (OMP_FOR_PRE_BODY (node
))
2838 if (TREE_CODE (node
) == CILK_FOR
)
2839 pp_string (pp
, " ");
2841 newline_and_indent (pp
, spc
+ 2);
2844 newline_and_indent (pp
, spc
);
2845 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
2848 if (OMP_FOR_INIT (node
))
2851 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
2854 if (TREE_CODE (node
) != CILK_FOR
|| OMP_FOR_PRE_BODY (node
))
2855 newline_and_indent (pp
, spc
);
2856 if (TREE_CODE (node
) == CILK_FOR
)
2857 pp_string (pp
, "_Cilk_for (");
2859 pp_string (pp
, "for (");
2860 dump_generic_node (pp
,
2861 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
2863 pp_string (pp
, "; ");
2864 dump_generic_node (pp
,
2865 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
2867 pp_string (pp
, "; ");
2868 dump_generic_node (pp
,
2869 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
2871 pp_right_paren (pp
);
2873 if (TREE_CODE (node
) == CILK_FOR
)
2874 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2876 if (OMP_FOR_BODY (node
))
2878 newline_and_indent (pp
, spc
+ 2);
2880 newline_and_indent (pp
, spc
+ 4);
2881 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
2883 newline_and_indent (pp
, spc
+ 2);
2884 pp_right_brace (pp
);
2886 if (OMP_FOR_INIT (node
))
2887 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
2888 if (OMP_FOR_PRE_BODY (node
))
2891 newline_and_indent (pp
, spc
+ 2);
2892 pp_right_brace (pp
);
2899 pp_string (pp
, "#pragma omp sections");
2900 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
2904 pp_string (pp
, "#pragma omp section");
2908 pp_string (pp
, "#pragma omp master");
2912 pp_string (pp
, "#pragma omp taskgroup");
2916 pp_string (pp
, "#pragma omp ordered");
2917 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
2921 pp_string (pp
, "#pragma omp critical");
2922 if (OMP_CRITICAL_NAME (node
))
2926 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
2928 pp_right_paren (pp
);
2930 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
2934 pp_string (pp
, "#pragma omp atomic");
2935 if (OMP_ATOMIC_SEQ_CST (node
))
2936 pp_string (pp
, " seq_cst");
2937 newline_and_indent (pp
, spc
+ 2);
2938 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2942 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2945 case OMP_ATOMIC_READ
:
2946 pp_string (pp
, "#pragma omp atomic read");
2947 if (OMP_ATOMIC_SEQ_CST (node
))
2948 pp_string (pp
, " seq_cst");
2949 newline_and_indent (pp
, spc
+ 2);
2950 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2954 case OMP_ATOMIC_CAPTURE_OLD
:
2955 case OMP_ATOMIC_CAPTURE_NEW
:
2956 pp_string (pp
, "#pragma omp atomic capture");
2957 if (OMP_ATOMIC_SEQ_CST (node
))
2958 pp_string (pp
, " seq_cst");
2959 newline_and_indent (pp
, spc
+ 2);
2960 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2964 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2968 pp_string (pp
, "#pragma omp single");
2969 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
2973 dump_omp_clause (pp
, node
, spc
, flags
);
2977 case TRANSACTION_EXPR
:
2978 if (TRANSACTION_EXPR_OUTER (node
))
2979 pp_string (pp
, "__transaction_atomic [[outer]]");
2980 else if (TRANSACTION_EXPR_RELAXED (node
))
2981 pp_string (pp
, "__transaction_relaxed");
2983 pp_string (pp
, "__transaction_atomic");
2984 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
2986 newline_and_indent (pp
, spc
);
2988 newline_and_indent (pp
, spc
+ 2);
2989 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
2990 spc
+ 2, flags
, false);
2991 newline_and_indent (pp
, spc
);
2992 pp_right_brace (pp
);
2997 case REDUC_MAX_EXPR
:
2998 pp_string (pp
, " REDUC_MAX_EXPR < ");
2999 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3000 pp_string (pp
, " > ");
3003 case REDUC_MIN_EXPR
:
3004 pp_string (pp
, " REDUC_MIN_EXPR < ");
3005 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3006 pp_string (pp
, " > ");
3009 case REDUC_PLUS_EXPR
:
3010 pp_string (pp
, " REDUC_PLUS_EXPR < ");
3011 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3012 pp_string (pp
, " > ");
3015 case VEC_WIDEN_MULT_HI_EXPR
:
3016 case VEC_WIDEN_MULT_LO_EXPR
:
3017 case VEC_WIDEN_MULT_EVEN_EXPR
:
3018 case VEC_WIDEN_MULT_ODD_EXPR
:
3019 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3020 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3022 for (str
= get_tree_code_name (code
); *str
; str
++)
3023 pp_character (pp
, TOUPPER (*str
));
3024 pp_string (pp
, " < ");
3025 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3026 pp_string (pp
, ", ");
3027 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3028 pp_string (pp
, " > ");
3031 case VEC_UNPACK_HI_EXPR
:
3032 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3033 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3034 pp_string (pp
, " > ");
3037 case VEC_UNPACK_LO_EXPR
:
3038 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3039 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3040 pp_string (pp
, " > ");
3043 case VEC_UNPACK_FLOAT_HI_EXPR
:
3044 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3045 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3046 pp_string (pp
, " > ");
3049 case VEC_UNPACK_FLOAT_LO_EXPR
:
3050 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3051 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3052 pp_string (pp
, " > ");
3055 case VEC_PACK_TRUNC_EXPR
:
3056 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3057 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3058 pp_string (pp
, ", ");
3059 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3060 pp_string (pp
, " > ");
3063 case VEC_PACK_SAT_EXPR
:
3064 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3065 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3066 pp_string (pp
, ", ");
3067 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3068 pp_string (pp
, " > ");
3071 case VEC_PACK_FIX_TRUNC_EXPR
:
3072 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3073 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3074 pp_string (pp
, ", ");
3075 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3076 pp_string (pp
, " > ");
3080 dump_block_node (pp
, node
, spc
, flags
);
3083 case CILK_SPAWN_STMT
:
3084 pp_string (pp
, "_Cilk_spawn ");
3085 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3088 case CILK_SYNC_STMT
:
3089 pp_string (pp
, "_Cilk_sync");
3096 if (is_stmt
&& is_expr
)
3102 /* Print the declaration of a variable. */
3105 print_declaration (pretty_printer
*pp
, tree t
, int spc
, int flags
)
3109 if (TREE_CODE(t
) == NAMELIST_DECL
)
3111 pp_string(pp
, "namelist ");
3112 dump_decl_name (pp
, t
, flags
);
3117 if (TREE_CODE (t
) == TYPE_DECL
)
3118 pp_string (pp
, "typedef ");
3120 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3121 pp_string (pp
, "register ");
3123 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3124 pp_string (pp
, "extern ");
3125 else if (TREE_STATIC (t
))
3126 pp_string (pp
, "static ");
3128 /* Print the type and name. */
3129 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3133 /* Print array's type. */
3134 tmp
= TREE_TYPE (t
);
3135 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3136 tmp
= TREE_TYPE (tmp
);
3137 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3139 /* Print variable's name. */
3141 dump_generic_node (pp
, t
, spc
, flags
, false);
3143 /* Print the dimensions. */
3144 tmp
= TREE_TYPE (t
);
3145 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3147 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3148 tmp
= TREE_TYPE (tmp
);
3151 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3153 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3155 dump_decl_name (pp
, t
, flags
);
3156 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3160 /* Print type declaration. */
3161 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3163 /* Print variable's name. */
3165 dump_generic_node (pp
, t
, spc
, flags
, false);
3168 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
3170 pp_string (pp
, " __asm__ ");
3172 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3173 pp_right_paren (pp
);
3176 /* The initial value of a function serves to determine whether the function
3177 is declared or defined. So the following does not apply to function
3179 if (TREE_CODE (t
) != FUNCTION_DECL
)
3181 /* Print the initial value. */
3182 if (DECL_INITIAL (t
))
3187 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3191 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
3193 pp_string (pp
, " [value-expr: ");
3194 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3195 pp_right_bracket (pp
);
3202 /* Prints a structure: name, fields, and methods.
3203 FIXME: Still incomplete. */
3206 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
, int flags
)
3208 /* Print the name of the structure. */
3209 if (TYPE_NAME (node
))
3212 if (TREE_CODE (node
) == RECORD_TYPE
)
3213 pp_string (pp
, "struct ");
3214 else if ((TREE_CODE (node
) == UNION_TYPE
3215 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3216 pp_string (pp
, "union ");
3218 dump_generic_node (pp
, TYPE_NAME (node
), spc
, 0, false);
3221 /* Print the contents of the structure. */
3227 /* Print the fields of the structure. */
3230 tmp
= TYPE_FIELDS (node
);
3233 /* Avoid to print recursively the structure. */
3234 /* FIXME : Not implemented correctly...,
3235 what about the case when we have a cycle in the contain graph? ...
3236 Maybe this could be solved by looking at the scope in which the
3237 structure was declared. */
3238 if (TREE_TYPE (tmp
) != node
3239 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3240 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3242 print_declaration (pp
, tmp
, spc
+2, flags
);
3245 tmp
= DECL_CHAIN (tmp
);
3249 pp_right_brace (pp
);
3252 /* Return the priority of the operator CODE.
3254 From lowest to highest precedence with either left-to-right (L-R)
3255 or right-to-left (R-L) associativity]:
3258 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3270 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3271 15 [L-R] fn() [] -> .
3273 unary +, - and * have higher precedence than the corresponding binary
3277 op_code_prio (enum tree_code code
)
3294 case TRUTH_ORIF_EXPR
:
3297 case TRUTH_AND_EXPR
:
3298 case TRUTH_ANDIF_EXPR
:
3305 case TRUTH_XOR_EXPR
:
3322 case UNORDERED_EXPR
:
3333 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3334 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3335 case WIDEN_LSHIFT_EXPR
:
3338 case WIDEN_SUM_EXPR
:
3340 case POINTER_PLUS_EXPR
:
3344 case VEC_WIDEN_MULT_HI_EXPR
:
3345 case VEC_WIDEN_MULT_LO_EXPR
:
3346 case WIDEN_MULT_EXPR
:
3348 case WIDEN_MULT_PLUS_EXPR
:
3349 case WIDEN_MULT_MINUS_EXPR
:
3351 case MULT_HIGHPART_EXPR
:
3352 case TRUNC_DIV_EXPR
:
3354 case FLOOR_DIV_EXPR
:
3355 case ROUND_DIV_EXPR
:
3357 case EXACT_DIV_EXPR
:
3358 case TRUNC_MOD_EXPR
:
3360 case FLOOR_MOD_EXPR
:
3361 case ROUND_MOD_EXPR
:
3365 case TRUTH_NOT_EXPR
:
3367 case POSTINCREMENT_EXPR
:
3368 case POSTDECREMENT_EXPR
:
3369 case PREINCREMENT_EXPR
:
3370 case PREDECREMENT_EXPR
:
3376 case FIX_TRUNC_EXPR
:
3382 case ARRAY_RANGE_REF
:
3386 /* Special expressions. */
3392 case REDUC_MAX_EXPR
:
3393 case REDUC_MIN_EXPR
:
3394 case REDUC_PLUS_EXPR
:
3395 case VEC_UNPACK_HI_EXPR
:
3396 case VEC_UNPACK_LO_EXPR
:
3397 case VEC_UNPACK_FLOAT_HI_EXPR
:
3398 case VEC_UNPACK_FLOAT_LO_EXPR
:
3399 case VEC_PACK_TRUNC_EXPR
:
3400 case VEC_PACK_SAT_EXPR
:
3404 /* Return an arbitrarily high precedence to avoid surrounding single
3405 VAR_DECLs in ()s. */
3410 /* Return the priority of the operator OP. */
3413 op_prio (const_tree op
)
3415 enum tree_code code
;
3420 code
= TREE_CODE (op
);
3421 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3422 return op_prio (TREE_OPERAND (op
, 0));
3424 return op_code_prio (code
);
3427 /* Return the symbol associated with operator CODE. */
3430 op_symbol_code (enum tree_code code
)
3438 case TRUTH_ORIF_EXPR
:
3441 case TRUTH_AND_EXPR
:
3442 case TRUTH_ANDIF_EXPR
:
3448 case TRUTH_XOR_EXPR
:
3458 case UNORDERED_EXPR
:
3504 case WIDEN_LSHIFT_EXPR
:
3507 case POINTER_PLUS_EXPR
:
3513 case REDUC_PLUS_EXPR
:
3516 case WIDEN_SUM_EXPR
:
3519 case WIDEN_MULT_EXPR
:
3522 case MULT_HIGHPART_EXPR
:
3532 case TRUTH_NOT_EXPR
:
3539 case TRUNC_DIV_EXPR
:
3546 case FLOOR_DIV_EXPR
:
3549 case ROUND_DIV_EXPR
:
3552 case EXACT_DIV_EXPR
:
3555 case TRUNC_MOD_EXPR
:
3561 case FLOOR_MOD_EXPR
:
3564 case ROUND_MOD_EXPR
:
3567 case PREDECREMENT_EXPR
:
3570 case PREINCREMENT_EXPR
:
3573 case POSTDECREMENT_EXPR
:
3576 case POSTINCREMENT_EXPR
:
3586 return "<<< ??? >>>";
3590 /* Return the symbol associated with operator OP. */
3593 op_symbol (const_tree op
)
3595 return op_symbol_code (TREE_CODE (op
));
3598 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3599 the gimple_call_fn of a GIMPLE_CALL. */
3602 print_call_name (pretty_printer
*pp
, tree node
, int flags
)
3606 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3607 op0
= TREE_OPERAND (op0
, 0);
3610 switch (TREE_CODE (op0
))
3615 dump_function_name (pp
, op0
, flags
);
3621 op0
= TREE_OPERAND (op0
, 0);
3626 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3627 pp_string (pp
, ") ? ");
3628 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3629 pp_string (pp
, " : ");
3630 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3634 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3635 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
3637 dump_generic_node (pp
, op0
, 0, flags
, false);
3641 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3643 op0
= TREE_OPERAND (op0
, 0);
3650 dump_generic_node (pp
, op0
, 0, flags
, false);
3658 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3661 pretty_print_string (pretty_printer
*pp
, const char *str
)
3671 pp_string (pp
, "\\b");
3675 pp_string (pp
, "\\f");
3679 pp_string (pp
, "\\n");
3683 pp_string (pp
, "\\r");
3687 pp_string (pp
, "\\t");
3691 pp_string (pp
, "\\v");
3695 pp_string (pp
, "\\\\");
3699 pp_string (pp
, "\\\"");
3703 pp_string (pp
, "\\'");
3706 /* No need to handle \0; the loop terminates on \0. */
3709 pp_string (pp
, "\\1");
3713 pp_string (pp
, "\\2");
3717 pp_string (pp
, "\\3");
3721 pp_string (pp
, "\\4");
3725 pp_string (pp
, "\\5");
3729 pp_string (pp
, "\\6");
3733 pp_string (pp
, "\\7");
3737 pp_character (pp
, str
[0]);
3745 maybe_init_pretty_print (FILE *file
)
3749 tree_pp
= new pretty_printer ();
3750 pp_needs_newline (tree_pp
) = true;
3751 pp_translate_identifiers (tree_pp
) = false;
3754 tree_pp
->buffer
->stream
= file
;
3758 newline_and_indent (pretty_printer
*pp
, int spc
)
3764 /* Handle a %K format for TEXT. Separate from default_tree_printer so
3765 it can also be used in front ends.
3766 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3770 percent_K_format (text_info
*text
)
3772 tree t
= va_arg (*text
->args_ptr
, tree
), block
;
3773 text
->set_location (0, EXPR_LOCATION (t
), true);
3774 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3775 block
= TREE_BLOCK (t
);
3776 *pp_ti_abstract_origin (text
) = NULL
;
3780 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3781 representing the outermost block of an inlined function.
3782 So walk the BLOCK tree until we hit such a scope. */
3784 && TREE_CODE (block
) == BLOCK
)
3786 if (inlined_function_outer_scope_p (block
))
3788 *pp_ti_abstract_origin (text
) = block
;
3791 block
= BLOCK_SUPERCONTEXT (block
);
3797 && TREE_CODE (block
) == BLOCK
3798 && BLOCK_ABSTRACT_ORIGIN (block
))
3800 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3802 while (TREE_CODE (ao
) == BLOCK
3803 && BLOCK_ABSTRACT_ORIGIN (ao
)
3804 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3805 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3807 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3809 *pp_ti_abstract_origin (text
) = block
;
3812 block
= BLOCK_SUPERCONTEXT (block
);
3816 /* Print the identifier ID to PRETTY-PRINTER. */
3819 pp_tree_identifier (pretty_printer
*pp
, tree id
)
3821 if (pp_translate_identifiers (pp
))
3823 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
3824 pp_append_text (pp
, text
, text
+ strlen (text
));
3827 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
3828 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
3831 /* A helper function that is used to dump function information before the
3835 dump_function_header (FILE *dump_file
, tree fdecl
, int flags
)
3837 const char *dname
, *aname
;
3838 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
3839 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
3841 dname
= lang_hooks
.decl_printable_name (fdecl
, 2);
3843 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
3844 aname
= (IDENTIFIER_POINTER
3845 (DECL_ASSEMBLER_NAME (fdecl
)));
3847 aname
= "<unset-asm-name>";
3849 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
3850 dname
, aname
, fun
->funcdef_no
);
3851 if (!(flags
& TDF_NOUID
))
3852 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
3855 fprintf (dump_file
, ", cgraph_uid=%d", node
->uid
);
3856 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
3857 node
->frequency
== NODE_FREQUENCY_HOT
3859 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
3860 ? " (unlikely executed)"
3861 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
3862 ? " (executed once)"
3866 fprintf (dump_file
, ")\n\n");
3869 /* Dump double_int D to pretty_printer PP. UNS is true
3870 if D is unsigned and false otherwise. */
3872 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
3875 pp_wide_integer (pp
, d
.low
);
3876 else if (d
.fits_uhwi ())
3877 pp_unsigned_wide_integer (pp
, d
.low
);
3880 unsigned HOST_WIDE_INT low
= d
.low
;
3881 HOST_WIDE_INT high
= d
.high
;
3882 if (!uns
&& d
.is_negative ())
3885 high
= ~high
+ !low
;
3888 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
3890 sprintf (pp_buffer (pp
)->digit_buffer
,
3891 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
3892 (unsigned HOST_WIDE_INT
) high
, low
);
3893 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);