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_TO_DECLARE
:
333 case OMP_CLAUSE_LINK
:
337 pp_string (pp
, name
);
339 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
344 case OMP_CLAUSE_REDUCTION
:
345 pp_string (pp
, "reduction(");
346 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
349 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
352 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
358 pp_string (pp
, "if(");
359 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
361 case ERROR_MARK
: break;
362 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
363 case OMP_TASK
: pp_string (pp
, "task:"); break;
364 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
365 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
366 case OMP_TARGET
: pp_string (pp
, "target:"); break;
367 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
368 case OMP_TARGET_ENTER_DATA
:
369 pp_string (pp
, "target enter data:"); break;
370 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
371 default: gcc_unreachable ();
373 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
378 case OMP_CLAUSE_NUM_THREADS
:
379 pp_string (pp
, "num_threads(");
380 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
385 case OMP_CLAUSE__CILK_FOR_COUNT_
:
386 pp_string (pp
, "_Cilk_for_count_(");
387 dump_generic_node (pp
, OMP_CLAUSE_OPERAND (clause
, 0),
392 case OMP_CLAUSE_NOWAIT
:
393 pp_string (pp
, "nowait");
395 case OMP_CLAUSE_ORDERED
:
396 pp_string (pp
, "ordered");
397 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
400 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
406 case OMP_CLAUSE_DEFAULT
:
407 pp_string (pp
, "default(");
408 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
410 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
412 case OMP_CLAUSE_DEFAULT_SHARED
:
413 pp_string (pp
, "shared");
415 case OMP_CLAUSE_DEFAULT_NONE
:
416 pp_string (pp
, "none");
418 case OMP_CLAUSE_DEFAULT_PRIVATE
:
419 pp_string (pp
, "private");
421 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
422 pp_string (pp
, "firstprivate");
430 case OMP_CLAUSE_SCHEDULE
:
431 pp_string (pp
, "schedule(");
432 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
433 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
434 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
436 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
437 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
438 pp_string (pp
, "monotonic");
440 pp_string (pp
, "nonmonotonic");
441 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
446 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
447 pp_string (pp
, "simd:");
449 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
451 case OMP_CLAUSE_SCHEDULE_STATIC
:
452 pp_string (pp
, "static");
454 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
455 pp_string (pp
, "dynamic");
457 case OMP_CLAUSE_SCHEDULE_GUIDED
:
458 pp_string (pp
, "guided");
460 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
461 pp_string (pp
, "runtime");
463 case OMP_CLAUSE_SCHEDULE_AUTO
:
464 pp_string (pp
, "auto");
466 case OMP_CLAUSE_SCHEDULE_CILKFOR
:
467 pp_string (pp
, "cilk-for grain");
472 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
475 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
481 case OMP_CLAUSE_UNTIED
:
482 pp_string (pp
, "untied");
485 case OMP_CLAUSE_COLLAPSE
:
486 pp_string (pp
, "collapse(");
487 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
492 case OMP_CLAUSE_FINAL
:
493 pp_string (pp
, "final(");
494 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
499 case OMP_CLAUSE_MERGEABLE
:
500 pp_string (pp
, "mergeable");
503 case OMP_CLAUSE_LINEAR
:
504 pp_string (pp
, "linear(");
505 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
507 case OMP_CLAUSE_LINEAR_DEFAULT
:
509 case OMP_CLAUSE_LINEAR_REF
:
510 pp_string (pp
, "ref(");
512 case OMP_CLAUSE_LINEAR_VAL
:
513 pp_string (pp
, "val(");
515 case OMP_CLAUSE_LINEAR_UVAL
:
516 pp_string (pp
, "uval(");
521 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
523 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
526 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
531 case OMP_CLAUSE_ALIGNED
:
532 pp_string (pp
, "aligned(");
533 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
535 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
538 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
544 case OMP_CLAUSE_DEPEND
:
545 pp_string (pp
, "depend(");
546 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
548 case OMP_CLAUSE_DEPEND_IN
:
549 pp_string (pp
, "in");
551 case OMP_CLAUSE_DEPEND_OUT
:
552 pp_string (pp
, "out");
554 case OMP_CLAUSE_DEPEND_INOUT
:
555 pp_string (pp
, "inout");
557 case OMP_CLAUSE_DEPEND_SOURCE
:
558 pp_string (pp
, "source)");
560 case OMP_CLAUSE_DEPEND_SINK
:
561 pp_string (pp
, "sink:");
562 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
563 if (TREE_CODE (t
) == TREE_LIST
)
565 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
566 if (TREE_PURPOSE (t
) != integer_zero_node
)
568 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
572 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
586 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
592 pp_string (pp
, "map(");
593 switch (OMP_CLAUSE_MAP_KIND (clause
))
596 case GOMP_MAP_POINTER
:
597 pp_string (pp
, "alloc");
600 case GOMP_MAP_TO_PSET
:
601 pp_string (pp
, "to");
604 pp_string (pp
, "from");
606 case GOMP_MAP_TOFROM
:
607 pp_string (pp
, "tofrom");
609 case GOMP_MAP_FORCE_ALLOC
:
610 pp_string (pp
, "force_alloc");
612 case GOMP_MAP_FORCE_TO
:
613 pp_string (pp
, "force_to");
615 case GOMP_MAP_FORCE_FROM
:
616 pp_string (pp
, "force_from");
618 case GOMP_MAP_FORCE_TOFROM
:
619 pp_string (pp
, "force_tofrom");
621 case GOMP_MAP_FORCE_PRESENT
:
622 pp_string (pp
, "force_present");
624 case GOMP_MAP_FORCE_DEALLOC
:
625 pp_string (pp
, "delete");
627 case GOMP_MAP_FORCE_DEVICEPTR
:
628 pp_string (pp
, "force_deviceptr");
630 case GOMP_MAP_ALWAYS_TO
:
631 pp_string (pp
, "always,to");
633 case GOMP_MAP_ALWAYS_FROM
:
634 pp_string (pp
, "always,from");
636 case GOMP_MAP_ALWAYS_TOFROM
:
637 pp_string (pp
, "always,tofrom");
639 case GOMP_MAP_RELEASE
:
640 pp_string (pp
, "release");
642 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
643 pp_string (pp
, "firstprivate");
645 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
646 pp_string (pp
, "firstprivate ref");
648 case GOMP_MAP_STRUCT
:
649 pp_string (pp
, "struct");
651 case GOMP_MAP_ALWAYS_POINTER
:
652 pp_string (pp
, "always_pointer");
654 case GOMP_MAP_DEVICE_RESIDENT
:
655 pp_string (pp
, "device_resident");
658 pp_string (pp
, "link");
664 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
667 if (OMP_CLAUSE_SIZE (clause
))
669 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
670 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
672 case GOMP_MAP_POINTER
:
673 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
674 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
675 case GOMP_MAP_ALWAYS_POINTER
:
676 pp_string (pp
, " [pointer assign, bias: ");
678 case GOMP_MAP_TO_PSET
:
679 pp_string (pp
, " [pointer set, len: ");
682 pp_string (pp
, " [len: ");
685 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
687 pp_right_bracket (pp
);
692 case OMP_CLAUSE_FROM
:
693 pp_string (pp
, "from(");
694 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
696 goto print_clause_size
;
699 pp_string (pp
, "to(");
700 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
702 goto print_clause_size
;
704 case OMP_CLAUSE__CACHE_
:
706 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
708 goto print_clause_size
;
710 case OMP_CLAUSE_NUM_TEAMS
:
711 pp_string (pp
, "num_teams(");
712 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
717 case OMP_CLAUSE_THREAD_LIMIT
:
718 pp_string (pp
, "thread_limit(");
719 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
724 case OMP_CLAUSE_DEVICE
:
725 pp_string (pp
, "device(");
726 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
731 case OMP_CLAUSE_DIST_SCHEDULE
:
732 pp_string (pp
, "dist_schedule(static");
733 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
736 dump_generic_node (pp
,
737 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
743 case OMP_CLAUSE_PROC_BIND
:
744 pp_string (pp
, "proc_bind(");
745 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
747 case OMP_CLAUSE_PROC_BIND_MASTER
:
748 pp_string (pp
, "master");
750 case OMP_CLAUSE_PROC_BIND_CLOSE
:
751 pp_string (pp
, "close");
753 case OMP_CLAUSE_PROC_BIND_SPREAD
:
754 pp_string (pp
, "spread");
762 case OMP_CLAUSE_SAFELEN
:
763 pp_string (pp
, "safelen(");
764 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
769 case OMP_CLAUSE_SIMDLEN
:
770 pp_string (pp
, "simdlen(");
771 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
776 case OMP_CLAUSE_PRIORITY
:
777 pp_string (pp
, "priority(");
778 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
783 case OMP_CLAUSE_GRAINSIZE
:
784 pp_string (pp
, "grainsize(");
785 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
790 case OMP_CLAUSE_NUM_TASKS
:
791 pp_string (pp
, "num_tasks(");
792 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
797 case OMP_CLAUSE_HINT
:
798 pp_string (pp
, "hint(");
799 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
804 case OMP_CLAUSE_DEFAULTMAP
:
805 pp_string (pp
, "defaultmap(tofrom:scalar)");
808 case OMP_CLAUSE__SIMDUID_
:
809 pp_string (pp
, "_simduid_(");
810 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
815 case OMP_CLAUSE_GANG
:
816 pp_string (pp
, "gang");
817 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
819 pp_string (pp
, "(num: ");
820 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
823 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
825 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
829 pp_string (pp
, "static:");
830 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
831 == integer_minus_one_node
)
832 pp_character (pp
, '*');
834 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
837 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
838 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
842 case OMP_CLAUSE_ASYNC
:
843 pp_string (pp
, "async");
844 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
846 pp_character(pp
, '(');
847 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
849 pp_character(pp
, ')');
853 case OMP_CLAUSE_AUTO
:
855 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
858 case OMP_CLAUSE_WAIT
:
859 pp_string (pp
, "wait(");
860 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
862 pp_character(pp
, ')');
865 case OMP_CLAUSE_WORKER
:
866 pp_string (pp
, "worker");
867 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
870 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
876 case OMP_CLAUSE_VECTOR
:
877 pp_string (pp
, "vector");
878 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
881 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
887 case OMP_CLAUSE_NUM_GANGS
:
888 pp_string (pp
, "num_gangs(");
889 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
891 pp_character (pp
, ')');
894 case OMP_CLAUSE_NUM_WORKERS
:
895 pp_string (pp
, "num_workers(");
896 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
898 pp_character (pp
, ')');
901 case OMP_CLAUSE_VECTOR_LENGTH
:
902 pp_string (pp
, "vector_length(");
903 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
905 pp_character (pp
, ')');
908 case OMP_CLAUSE_INBRANCH
:
909 pp_string (pp
, "inbranch");
911 case OMP_CLAUSE_NOTINBRANCH
:
912 pp_string (pp
, "notinbranch");
915 pp_string (pp
, "for");
917 case OMP_CLAUSE_PARALLEL
:
918 pp_string (pp
, "parallel");
920 case OMP_CLAUSE_SECTIONS
:
921 pp_string (pp
, "sections");
923 case OMP_CLAUSE_TASKGROUP
:
924 pp_string (pp
, "taskgroup");
926 case OMP_CLAUSE_NOGROUP
:
927 pp_string (pp
, "nogroup");
929 case OMP_CLAUSE_THREADS
:
930 pp_string (pp
, "threads");
932 case OMP_CLAUSE_SIMD
:
933 pp_string (pp
, "simd");
935 case OMP_CLAUSE_INDEPENDENT
:
936 pp_string (pp
, "independent");
938 case OMP_CLAUSE_TILE
:
939 pp_string (pp
, "tile(");
940 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
946 /* Should never happen. */
947 dump_generic_node (pp
, clause
, spc
, flags
, false);
953 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
954 dump_generic_node. */
957 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, int flags
)
965 dump_omp_clause (pp
, clause
, spc
, flags
);
966 clause
= OMP_CLAUSE_CHAIN (clause
);
974 /* Dump location LOC to PP. */
977 dump_location (pretty_printer
*pp
, location_t loc
)
979 expanded_location xloc
= expand_location (loc
);
981 pp_left_bracket (pp
);
984 pp_string (pp
, xloc
.file
);
987 pp_decimal_int (pp
, xloc
.line
);
989 pp_decimal_int (pp
, xloc
.column
);
990 pp_string (pp
, "] ");
994 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
995 dump_generic_node. */
998 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, int flags
)
1002 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1004 if (flags
& TDF_ADDRESS
)
1005 pp_printf (pp
, "[%p] ", (void *) block
);
1007 if (BLOCK_ABSTRACT (block
))
1008 pp_string (pp
, "[abstract] ");
1010 if (TREE_ASM_WRITTEN (block
))
1011 pp_string (pp
, "[written] ");
1013 if (flags
& TDF_SLIM
)
1016 if (BLOCK_SOURCE_LOCATION (block
))
1017 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1019 newline_and_indent (pp
, spc
+ 2);
1021 if (BLOCK_SUPERCONTEXT (block
))
1023 pp_string (pp
, "SUPERCONTEXT: ");
1024 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1025 flags
| TDF_SLIM
, false);
1026 newline_and_indent (pp
, spc
+ 2);
1029 if (BLOCK_SUBBLOCKS (block
))
1031 pp_string (pp
, "SUBBLOCKS: ");
1032 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1034 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1037 newline_and_indent (pp
, spc
+ 2);
1040 if (BLOCK_CHAIN (block
))
1042 pp_string (pp
, "SIBLINGS: ");
1043 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1045 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1048 newline_and_indent (pp
, spc
+ 2);
1051 if (BLOCK_VARS (block
))
1053 pp_string (pp
, "VARS: ");
1054 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1056 dump_generic_node (pp
, t
, 0, flags
, false);
1059 newline_and_indent (pp
, spc
+ 2);
1062 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1065 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1067 pp_string (pp
, "NONLOCALIZED_VARS: ");
1068 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1070 dump_generic_node (pp
, t
, 0, flags
, false);
1073 newline_and_indent (pp
, spc
+ 2);
1076 if (BLOCK_ABSTRACT_ORIGIN (block
))
1078 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1079 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1080 flags
| TDF_SLIM
, false);
1081 newline_and_indent (pp
, spc
+ 2);
1084 if (BLOCK_FRAGMENT_ORIGIN (block
))
1086 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1087 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1088 flags
| TDF_SLIM
, false);
1089 newline_and_indent (pp
, spc
+ 2);
1092 if (BLOCK_FRAGMENT_CHAIN (block
))
1094 pp_string (pp
, "FRAGMENT_CHAIN: ");
1095 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1097 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1100 newline_and_indent (pp
, spc
+ 2);
1105 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1106 indent. FLAGS specifies details to show in the dump (see TDF_* in
1107 dumpfile.h). If IS_STMT is true, the object printed is considered
1108 to be a statement and it is terminated by ';' if appropriate. */
1111 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, int flags
,
1118 enum tree_code code
;
1120 if (node
== NULL_TREE
)
1123 is_expr
= EXPR_P (node
);
1125 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1126 pp_printf (pp
, "<&%p> ", (void *)node
);
1128 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1129 dump_location (pp
, EXPR_LOCATION (node
));
1131 code
= TREE_CODE (node
);
1135 pp_string (pp
, "<<< error >>>");
1138 case IDENTIFIER_NODE
:
1139 pp_tree_identifier (pp
, node
);
1143 while (node
&& node
!= error_mark_node
)
1145 if (TREE_PURPOSE (node
))
1147 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1150 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1151 node
= TREE_CHAIN (node
);
1152 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1161 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1167 if (TREE_VEC_LENGTH (node
) > 0)
1169 size_t len
= TREE_VEC_LENGTH (node
);
1170 for (i
= 0; i
< len
- 1; i
++)
1172 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1177 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1184 case POINTER_BOUNDS_TYPE
:
1187 case FIXED_POINT_TYPE
:
1193 unsigned int quals
= TYPE_QUALS (node
);
1194 enum tree_code_class tclass
;
1196 if (quals
& TYPE_QUAL_ATOMIC
)
1197 pp_string (pp
, "atomic ");
1198 if (quals
& TYPE_QUAL_CONST
)
1199 pp_string (pp
, "const ");
1200 else if (quals
& TYPE_QUAL_VOLATILE
)
1201 pp_string (pp
, "volatile ");
1202 else if (quals
& TYPE_QUAL_RESTRICT
)
1203 pp_string (pp
, "restrict ");
1205 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1207 pp_string (pp
, "<address-space-");
1208 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1209 pp_string (pp
, "> ");
1212 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1214 if (tclass
== tcc_declaration
)
1216 if (DECL_NAME (node
))
1217 dump_decl_name (pp
, node
, flags
);
1219 pp_string (pp
, "<unnamed type decl>");
1221 else if (tclass
== tcc_type
)
1223 if (TYPE_NAME (node
))
1225 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1226 pp_tree_identifier (pp
, TYPE_NAME (node
));
1227 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1228 && DECL_NAME (TYPE_NAME (node
)))
1229 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1231 pp_string (pp
, "<unnamed type>");
1233 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1235 pp_string (pp
, "vector");
1237 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1238 pp_string (pp
, ") ");
1239 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1241 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1243 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1244 pp_string (pp
, (TYPE_UNSIGNED (node
)
1247 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1248 pp_string (pp
, (TYPE_UNSIGNED (node
)
1251 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1252 pp_string (pp
, (TYPE_UNSIGNED (node
)
1255 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1256 pp_string (pp
, (TYPE_UNSIGNED (node
)
1259 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1260 pp_string (pp
, (TYPE_UNSIGNED (node
)
1261 ? "unsigned long long"
1262 : "signed long long"));
1263 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1264 && exact_log2 (TYPE_PRECISION (node
)) != -1)
1266 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1267 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1268 pp_string (pp
, "_t");
1272 pp_string (pp
, (TYPE_UNSIGNED (node
)
1273 ? "<unnamed-unsigned:"
1274 : "<unnamed-signed:"));
1275 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1279 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1281 pp_string (pp
, "__complex__ ");
1282 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1284 else if (TREE_CODE (node
) == REAL_TYPE
)
1286 pp_string (pp
, "<float:");
1287 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1290 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1292 pp_string (pp
, "<fixed-point-");
1293 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1294 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1297 else if (TREE_CODE (node
) == VOID_TYPE
)
1298 pp_string (pp
, "void");
1300 pp_string (pp
, "<unnamed type>");
1306 case REFERENCE_TYPE
:
1307 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1309 if (TREE_TYPE (node
) == NULL
)
1311 pp_string (pp
, str
);
1312 pp_string (pp
, "<null type>");
1314 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1316 tree fnode
= TREE_TYPE (node
);
1318 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1321 pp_string (pp
, str
);
1322 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1323 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1324 else if (flags
& TDF_NOUID
)
1325 pp_printf (pp
, "<Txxxx>");
1327 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1329 pp_right_paren (pp
);
1330 dump_function_declaration (pp
, fnode
, spc
, flags
);
1334 unsigned int quals
= TYPE_QUALS (node
);
1336 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1338 pp_string (pp
, str
);
1340 if (quals
& TYPE_QUAL_CONST
)
1341 pp_string (pp
, " const");
1342 if (quals
& TYPE_QUAL_VOLATILE
)
1343 pp_string (pp
, " volatile");
1344 if (quals
& TYPE_QUAL_RESTRICT
)
1345 pp_string (pp
, " restrict");
1347 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1349 pp_string (pp
, " <address-space-");
1350 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1354 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1355 pp_string (pp
, " {ref-all}");
1365 if (integer_zerop (TREE_OPERAND (node
, 1))
1366 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1367 infer them and MEM_ATTR caching will share MEM_REFs
1368 with differently-typed op0s. */
1369 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1370 /* Released SSA_NAMES have no TREE_TYPE. */
1371 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1372 /* Same pointer types, but ignoring POINTER_TYPE vs.
1374 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1375 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1376 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1377 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1378 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1379 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1380 /* Same value types ignoring qualifiers. */
1381 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1382 == TYPE_MAIN_VARIANT
1383 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1384 && (!(flags
& TDF_ALIAS
)
1385 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1387 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1390 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1394 dump_generic_node (pp
,
1395 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1402 pp_string (pp
, "MEM[");
1404 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1405 dump_generic_node (pp
, ptype
,
1406 spc
, flags
| TDF_SLIM
, false);
1407 pp_right_paren (pp
);
1408 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1410 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1412 pp_string (pp
, " + ");
1413 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1416 if ((flags
& TDF_ALIAS
)
1417 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1419 pp_string (pp
, " clique ");
1420 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1421 pp_string (pp
, " base ");
1422 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1424 pp_right_bracket (pp
);
1429 case TARGET_MEM_REF
:
1431 const char *sep
= "";
1434 pp_string (pp
, "MEM[");
1436 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1438 pp_string (pp
, sep
);
1440 pp_string (pp
, "symbol: ");
1441 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1446 pp_string (pp
, sep
);
1448 pp_string (pp
, "base: ");
1449 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1451 tmp
= TMR_INDEX2 (node
);
1454 pp_string (pp
, sep
);
1456 pp_string (pp
, "base: ");
1457 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1459 tmp
= TMR_INDEX (node
);
1462 pp_string (pp
, sep
);
1464 pp_string (pp
, "index: ");
1465 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1467 tmp
= TMR_STEP (node
);
1470 pp_string (pp
, sep
);
1472 pp_string (pp
, "step: ");
1473 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1475 tmp
= TMR_OFFSET (node
);
1478 pp_string (pp
, sep
);
1480 pp_string (pp
, "offset: ");
1481 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1483 pp_right_bracket (pp
);
1491 /* Print the innermost component type. */
1492 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1493 tmp
= TREE_TYPE (tmp
))
1495 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1497 /* Print the dimensions. */
1498 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1499 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1505 case QUAL_UNION_TYPE
:
1507 unsigned int quals
= TYPE_QUALS (node
);
1509 if (quals
& TYPE_QUAL_ATOMIC
)
1510 pp_string (pp
, "atomic ");
1511 if (quals
& TYPE_QUAL_CONST
)
1512 pp_string (pp
, "const ");
1513 if (quals
& TYPE_QUAL_VOLATILE
)
1514 pp_string (pp
, "volatile ");
1516 /* Print the name of the structure. */
1517 if (TREE_CODE (node
) == RECORD_TYPE
)
1518 pp_string (pp
, "struct ");
1519 else if (TREE_CODE (node
) == UNION_TYPE
)
1520 pp_string (pp
, "union ");
1522 if (TYPE_NAME (node
))
1523 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1524 else if (!(flags
& TDF_SLIM
))
1525 /* FIXME: If we eliminate the 'else' above and attempt
1526 to show the fields for named types, we may get stuck
1527 following a cycle of pointers to structs. The alleged
1528 self-reference check in print_struct_decl will not detect
1529 cycles involving more than one pointer or struct type. */
1530 print_struct_decl (pp
, node
, spc
, flags
);
1539 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
1541 /* In the case of a pointer, one may want to divide by the
1542 size of the pointed-to type. Unfortunately, this not
1543 straightforward. The C front-end maps expressions
1548 in such a way that the two INTEGER_CST nodes for "5" have
1549 different values but identical types. In the latter
1550 case, the 5 is multiplied by sizeof (int) in c-common.c
1551 (pointer_int_sum) to convert it to a byte address, and
1552 yet the type of the node is left unchanged. Argh. What
1553 is consistent though is that the number value corresponds
1554 to bytes (UNITS) offset.
1556 NB: Neither of the following divisors can be trivially
1557 used to recover the original literal:
1559 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1560 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1561 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1562 pp_string (pp
, "B"); /* pseudo-unit */
1564 else if (tree_fits_shwi_p (node
))
1565 pp_wide_integer (pp
, tree_to_shwi (node
));
1566 else if (tree_fits_uhwi_p (node
))
1567 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1570 wide_int val
= node
;
1572 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1577 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
1578 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
1580 if (TREE_OVERFLOW (node
))
1581 pp_string (pp
, "(OVF)");
1585 /* Code copied from print_node. */
1588 if (TREE_OVERFLOW (node
))
1589 pp_string (pp
, " overflow");
1591 d
= TREE_REAL_CST (node
);
1592 if (REAL_VALUE_ISINF (d
))
1593 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1594 else if (REAL_VALUE_ISNAN (d
))
1595 pp_string (pp
, " Nan");
1599 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1600 pp_string (pp
, string
);
1608 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1609 pp_string (pp
, string
);
1614 pp_string (pp
, "__complex__ (");
1615 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
1616 pp_string (pp
, ", ");
1617 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
1618 pp_right_paren (pp
);
1622 pp_string (pp
, "\"");
1623 pretty_print_string (pp
, TREE_STRING_POINTER (node
));
1624 pp_string (pp
, "\"");
1630 pp_string (pp
, "{ ");
1631 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1634 pp_string (pp
, ", ");
1635 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
1638 pp_string (pp
, " }");
1644 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1646 if (TREE_CODE (node
) == METHOD_TYPE
)
1648 if (TYPE_METHOD_BASETYPE (node
))
1649 dump_decl_name (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1652 pp_string (pp
, "<null method basetype>");
1653 pp_colon_colon (pp
);
1655 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1656 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1657 else if (flags
& TDF_NOUID
)
1658 pp_printf (pp
, "<Txxxx>");
1660 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1661 dump_function_declaration (pp
, node
, spc
, flags
);
1666 dump_decl_name (pp
, node
, flags
);
1670 if (DECL_NAME (node
))
1671 dump_decl_name (pp
, node
, flags
);
1672 else if (LABEL_DECL_UID (node
) != -1)
1673 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
1676 if (flags
& TDF_NOUID
)
1677 pp_string (pp
, "<D.xxxx>");
1679 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
1684 if (DECL_IS_BUILTIN (node
))
1686 /* Don't print the declaration of built-in types. */
1689 if (DECL_NAME (node
))
1690 dump_decl_name (pp
, node
, flags
);
1691 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1693 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1694 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1695 && TYPE_METHODS (TREE_TYPE (node
)))
1697 /* The type is a c++ class: all structures have at least
1699 pp_string (pp
, "class ");
1700 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1705 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1706 ? "union" : "struct "));
1707 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1711 pp_string (pp
, "<anon>");
1717 case DEBUG_EXPR_DECL
:
1718 case NAMESPACE_DECL
:
1720 dump_decl_name (pp
, node
, flags
);
1724 pp_string (pp
, "<retval>");
1728 op0
= TREE_OPERAND (node
, 0);
1731 && (TREE_CODE (op0
) == INDIRECT_REF
1732 || (TREE_CODE (op0
) == MEM_REF
1733 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1734 && integer_zerop (TREE_OPERAND (op0
, 1))
1735 /* Dump the types of INTEGER_CSTs explicitly, for we
1736 can't infer them and MEM_ATTR caching will share
1737 MEM_REFs with differently-typed op0s. */
1738 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1739 /* Released SSA_NAMES have no TREE_TYPE. */
1740 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1741 /* Same pointer types, but ignoring POINTER_TYPE vs.
1743 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1744 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1745 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1746 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1747 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1748 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1749 /* Same value types ignoring qualifiers. */
1750 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1751 == TYPE_MAIN_VARIANT
1752 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
1753 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
1755 op0
= TREE_OPERAND (op0
, 0);
1758 if (op_prio (op0
) < op_prio (node
))
1760 dump_generic_node (pp
, op0
, spc
, flags
, false);
1761 if (op_prio (op0
) < op_prio (node
))
1762 pp_right_paren (pp
);
1763 pp_string (pp
, str
);
1764 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1765 op0
= component_ref_field_offset (node
);
1766 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1768 pp_string (pp
, "{off: ");
1769 dump_generic_node (pp
, op0
, spc
, flags
, false);
1770 pp_right_brace (pp
);
1775 pp_string (pp
, "BIT_FIELD_REF <");
1776 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1777 pp_string (pp
, ", ");
1778 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1779 pp_string (pp
, ", ");
1780 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1785 case ARRAY_RANGE_REF
:
1786 op0
= TREE_OPERAND (node
, 0);
1787 if (op_prio (op0
) < op_prio (node
))
1789 dump_generic_node (pp
, op0
, spc
, flags
, false);
1790 if (op_prio (op0
) < op_prio (node
))
1791 pp_right_paren (pp
);
1792 pp_left_bracket (pp
);
1793 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1794 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1795 pp_string (pp
, " ...");
1796 pp_right_bracket (pp
);
1798 op0
= array_ref_low_bound (node
);
1799 op1
= array_ref_element_size (node
);
1801 if (!integer_zerop (op0
)
1802 || TREE_OPERAND (node
, 2)
1803 || TREE_OPERAND (node
, 3))
1805 pp_string (pp
, "{lb: ");
1806 dump_generic_node (pp
, op0
, spc
, flags
, false);
1807 pp_string (pp
, " sz: ");
1808 dump_generic_node (pp
, op1
, spc
, flags
, false);
1809 pp_right_brace (pp
);
1815 unsigned HOST_WIDE_INT ix
;
1817 bool is_struct_init
= false;
1818 bool is_array_init
= false;
1821 if (TREE_CLOBBER_P (node
))
1822 pp_string (pp
, "CLOBBER");
1823 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1824 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1825 is_struct_init
= true;
1826 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
1827 && TYPE_DOMAIN (TREE_TYPE (node
))
1828 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
1829 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
1832 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
1833 is_array_init
= true;
1834 curidx
= wi::to_widest (minv
);
1836 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1843 dump_generic_node (pp
, field
, spc
, flags
, false);
1846 else if (is_array_init
1847 && (TREE_CODE (field
) != INTEGER_CST
1848 || curidx
!= wi::to_widest (field
)))
1850 pp_left_bracket (pp
);
1851 if (TREE_CODE (field
) == RANGE_EXPR
)
1853 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
1855 pp_string (pp
, " ... ");
1856 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
1858 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
1859 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
1862 dump_generic_node (pp
, field
, spc
, flags
, false);
1863 if (TREE_CODE (field
) == INTEGER_CST
)
1864 curidx
= wi::to_widest (field
);
1865 pp_string (pp
, "]=");
1870 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1871 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1872 val
= TREE_OPERAND (val
, 0);
1873 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1874 dump_decl_name (pp
, val
, flags
);
1876 dump_generic_node (pp
, val
, spc
, flags
, false);
1877 if (ix
!= vec_safe_length (CONSTRUCTOR_ELTS (node
)) - 1)
1883 pp_right_brace (pp
);
1890 if (flags
& TDF_SLIM
)
1892 pp_string (pp
, "<COMPOUND_EXPR>");
1896 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1897 spc
, flags
, !(flags
& TDF_SLIM
));
1898 if (flags
& TDF_SLIM
)
1899 newline_and_indent (pp
, spc
);
1906 for (tp
= &TREE_OPERAND (node
, 1);
1907 TREE_CODE (*tp
) == COMPOUND_EXPR
;
1908 tp
= &TREE_OPERAND (*tp
, 1))
1910 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
1911 spc
, flags
, !(flags
& TDF_SLIM
));
1912 if (flags
& TDF_SLIM
)
1913 newline_and_indent (pp
, spc
);
1921 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
1925 case STATEMENT_LIST
:
1927 tree_stmt_iterator si
;
1930 if (flags
& TDF_SLIM
)
1932 pp_string (pp
, "<STATEMENT_LIST>");
1936 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
1939 newline_and_indent (pp
, spc
);
1942 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
1949 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
1954 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
1959 pp_string (pp
, "TARGET_EXPR <");
1960 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
1963 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
1968 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
1973 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
1975 pp_string (pp
, "if (");
1976 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
1977 pp_right_paren (pp
);
1978 /* The lowered cond_exprs should always be printed in full. */
1979 if (COND_EXPR_THEN (node
)
1980 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
1981 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
1982 && COND_EXPR_ELSE (node
)
1983 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
1984 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
1987 dump_generic_node (pp
, COND_EXPR_THEN (node
),
1989 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1991 pp_string (pp
, " else ");
1992 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
1996 else if (!(flags
& TDF_SLIM
))
1998 /* Output COND_EXPR_THEN. */
1999 if (COND_EXPR_THEN (node
))
2001 newline_and_indent (pp
, spc
+2);
2003 newline_and_indent (pp
, spc
+4);
2004 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2006 newline_and_indent (pp
, spc
+2);
2007 pp_right_brace (pp
);
2010 /* Output COND_EXPR_ELSE. */
2011 if (COND_EXPR_ELSE (node
)
2012 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2014 newline_and_indent (pp
, spc
);
2015 pp_string (pp
, "else");
2016 newline_and_indent (pp
, spc
+2);
2018 newline_and_indent (pp
, spc
+4);
2019 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2021 newline_and_indent (pp
, spc
+2);
2022 pp_right_brace (pp
);
2029 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2033 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2037 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2043 if (!(flags
& TDF_SLIM
))
2045 if (BIND_EXPR_VARS (node
))
2049 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2051 print_declaration (pp
, op0
, spc
+2, flags
);
2056 newline_and_indent (pp
, spc
+2);
2057 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2058 newline_and_indent (pp
, spc
);
2059 pp_right_brace (pp
);
2065 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2066 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2068 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2070 /* Print parameters. */
2075 call_expr_arg_iterator iter
;
2076 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2078 dump_generic_node (pp
, arg
, spc
, flags
, false);
2079 if (more_call_expr_args_p (&iter
))
2086 if (CALL_EXPR_VA_ARG_PACK (node
))
2088 if (call_expr_nargs (node
) > 0)
2093 pp_string (pp
, "__builtin_va_arg_pack ()");
2095 pp_right_paren (pp
);
2097 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2100 pp_string (pp
, " [static-chain: ");
2101 dump_generic_node (pp
, op1
, spc
, flags
, false);
2102 pp_right_bracket (pp
);
2105 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2106 pp_string (pp
, " [return slot optimization]");
2107 if (CALL_EXPR_TAILCALL (node
))
2108 pp_string (pp
, " [tail call]");
2111 case WITH_CLEANUP_EXPR
:
2115 case CLEANUP_POINT_EXPR
:
2116 pp_string (pp
, "<<cleanup_point ");
2117 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2118 pp_string (pp
, ">>");
2121 case PLACEHOLDER_EXPR
:
2122 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2123 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2127 /* Binary arithmetic and logic expressions. */
2128 case WIDEN_SUM_EXPR
:
2129 case WIDEN_MULT_EXPR
:
2131 case MULT_HIGHPART_EXPR
:
2133 case POINTER_PLUS_EXPR
:
2135 case TRUNC_DIV_EXPR
:
2137 case FLOOR_DIV_EXPR
:
2138 case ROUND_DIV_EXPR
:
2139 case TRUNC_MOD_EXPR
:
2141 case FLOOR_MOD_EXPR
:
2142 case ROUND_MOD_EXPR
:
2144 case EXACT_DIV_EXPR
:
2149 case WIDEN_LSHIFT_EXPR
:
2153 case TRUTH_ANDIF_EXPR
:
2154 case TRUTH_ORIF_EXPR
:
2155 case TRUTH_AND_EXPR
:
2157 case TRUTH_XOR_EXPR
:
2171 case UNORDERED_EXPR
:
2173 const char *op
= op_symbol (node
);
2174 op0
= TREE_OPERAND (node
, 0);
2175 op1
= TREE_OPERAND (node
, 1);
2177 /* When the operands are expressions with less priority,
2178 keep semantics of the tree representation. */
2179 if (op_prio (op0
) <= op_prio (node
))
2182 dump_generic_node (pp
, op0
, spc
, flags
, false);
2183 pp_right_paren (pp
);
2186 dump_generic_node (pp
, op0
, spc
, flags
, false);
2192 /* When the operands are expressions with less priority,
2193 keep semantics of the tree representation. */
2194 if (op_prio (op1
) <= op_prio (node
))
2197 dump_generic_node (pp
, op1
, spc
, flags
, false);
2198 pp_right_paren (pp
);
2201 dump_generic_node (pp
, op1
, spc
, flags
, false);
2205 /* Unary arithmetic and logic expressions. */
2208 case TRUTH_NOT_EXPR
:
2210 case PREDECREMENT_EXPR
:
2211 case PREINCREMENT_EXPR
:
2213 if (TREE_CODE (node
) == ADDR_EXPR
2214 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2215 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2216 ; /* Do not output '&' for strings and function pointers. */
2218 pp_string (pp
, op_symbol (node
));
2220 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2223 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2224 pp_right_paren (pp
);
2227 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2230 case POSTDECREMENT_EXPR
:
2231 case POSTINCREMENT_EXPR
:
2232 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2235 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2236 pp_right_paren (pp
);
2239 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2240 pp_string (pp
, op_symbol (node
));
2244 pp_string (pp
, "MIN_EXPR <");
2245 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2246 pp_string (pp
, ", ");
2247 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2252 pp_string (pp
, "MAX_EXPR <");
2253 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2254 pp_string (pp
, ", ");
2255 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2260 pp_string (pp
, "ABS_EXPR <");
2261 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2269 case ADDR_SPACE_CONVERT_EXPR
:
2270 case FIXED_CONVERT_EXPR
:
2271 case FIX_TRUNC_EXPR
:
2274 type
= TREE_TYPE (node
);
2275 op0
= TREE_OPERAND (node
, 0);
2276 if (type
!= TREE_TYPE (op0
))
2279 dump_generic_node (pp
, type
, spc
, flags
, false);
2280 pp_string (pp
, ") ");
2282 if (op_prio (op0
) < op_prio (node
))
2284 dump_generic_node (pp
, op0
, spc
, flags
, false);
2285 if (op_prio (op0
) < op_prio (node
))
2286 pp_right_paren (pp
);
2289 case VIEW_CONVERT_EXPR
:
2290 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2291 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2292 pp_string (pp
, ">(");
2293 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2294 pp_right_paren (pp
);
2298 pp_string (pp
, "((");
2299 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2300 pp_string (pp
, "))");
2303 case NON_LVALUE_EXPR
:
2304 pp_string (pp
, "NON_LVALUE_EXPR <");
2305 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2310 pp_string (pp
, "SAVE_EXPR <");
2311 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2316 pp_string (pp
, "COMPLEX_EXPR <");
2317 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2318 pp_string (pp
, ", ");
2319 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2324 pp_string (pp
, "CONJ_EXPR <");
2325 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2330 pp_string (pp
, "REALPART_EXPR <");
2331 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2336 pp_string (pp
, "IMAGPART_EXPR <");
2337 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2342 pp_string (pp
, "VA_ARG_EXPR <");
2343 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2347 case TRY_FINALLY_EXPR
:
2348 case TRY_CATCH_EXPR
:
2349 pp_string (pp
, "try");
2350 newline_and_indent (pp
, spc
+2);
2352 newline_and_indent (pp
, spc
+4);
2353 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2354 newline_and_indent (pp
, spc
+2);
2355 pp_right_brace (pp
);
2356 newline_and_indent (pp
, spc
);
2358 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2359 newline_and_indent (pp
, spc
+2);
2361 newline_and_indent (pp
, spc
+4);
2362 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2363 newline_and_indent (pp
, spc
+2);
2364 pp_right_brace (pp
);
2369 pp_string (pp
, "catch (");
2370 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2371 pp_right_paren (pp
);
2372 newline_and_indent (pp
, spc
+2);
2374 newline_and_indent (pp
, spc
+4);
2375 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2376 newline_and_indent (pp
, spc
+2);
2377 pp_right_brace (pp
);
2381 case EH_FILTER_EXPR
:
2382 pp_string (pp
, "<<<eh_filter (");
2383 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2384 pp_string (pp
, ")>>>");
2385 newline_and_indent (pp
, spc
+2);
2387 newline_and_indent (pp
, spc
+4);
2388 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2389 newline_and_indent (pp
, spc
+2);
2390 pp_right_brace (pp
);
2395 op0
= TREE_OPERAND (node
, 0);
2396 /* If this is for break or continue, don't bother printing it. */
2397 if (DECL_NAME (op0
))
2399 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2400 if (strcmp (name
, "break") == 0
2401 || strcmp (name
, "continue") == 0)
2404 dump_generic_node (pp
, op0
, spc
, flags
, false);
2406 if (DECL_NONLOCAL (op0
))
2407 pp_string (pp
, " [non-local]");
2411 pp_string (pp
, "while (1)");
2412 if (!(flags
& TDF_SLIM
))
2414 newline_and_indent (pp
, spc
+2);
2416 newline_and_indent (pp
, spc
+4);
2417 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2418 newline_and_indent (pp
, spc
+2);
2419 pp_right_brace (pp
);
2425 pp_string (pp
, "// predicted ");
2426 if (PREDICT_EXPR_OUTCOME (node
))
2427 pp_string (pp
, "likely by ");
2429 pp_string (pp
, "unlikely by ");
2430 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2431 pp_string (pp
, " predictor.");
2435 pp_string (pp
, "ANNOTATE_EXPR <");
2436 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2437 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2439 case annot_expr_ivdep_kind
:
2440 pp_string (pp
, ", ivdep");
2442 case annot_expr_no_vector_kind
:
2443 pp_string (pp
, ", no-vector");
2445 case annot_expr_vector_kind
:
2446 pp_string (pp
, ", vector");
2455 pp_string (pp
, "return");
2456 op0
= TREE_OPERAND (node
, 0);
2460 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2461 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2464 dump_generic_node (pp
, op0
, spc
, flags
, false);
2469 pp_string (pp
, "if (");
2470 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2471 pp_string (pp
, ") break");
2475 pp_string (pp
, "switch (");
2476 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2477 pp_right_paren (pp
);
2478 if (!(flags
& TDF_SLIM
))
2480 newline_and_indent (pp
, spc
+2);
2482 if (SWITCH_BODY (node
))
2484 newline_and_indent (pp
, spc
+4);
2485 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2490 tree vec
= SWITCH_LABELS (node
);
2491 size_t i
, n
= TREE_VEC_LENGTH (vec
);
2492 for (i
= 0; i
< n
; ++i
)
2494 tree elt
= TREE_VEC_ELT (vec
, i
);
2495 newline_and_indent (pp
, spc
+4);
2498 dump_generic_node (pp
, elt
, spc
+4, flags
, false);
2499 pp_string (pp
, " goto ");
2500 dump_generic_node (pp
, CASE_LABEL (elt
), spc
+4,
2505 pp_string (pp
, "case ???: goto ???;");
2508 newline_and_indent (pp
, spc
+2);
2509 pp_right_brace (pp
);
2515 op0
= GOTO_DESTINATION (node
);
2516 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2518 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2519 if (strcmp (name
, "break") == 0
2520 || strcmp (name
, "continue") == 0)
2522 pp_string (pp
, name
);
2526 pp_string (pp
, "goto ");
2527 dump_generic_node (pp
, op0
, spc
, flags
, false);
2531 pp_string (pp
, "__asm__");
2532 if (ASM_VOLATILE_P (node
))
2533 pp_string (pp
, " __volatile__");
2535 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2537 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2539 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2540 if (ASM_CLOBBERS (node
))
2543 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2545 pp_right_paren (pp
);
2548 case CASE_LABEL_EXPR
:
2549 if (CASE_LOW (node
) && CASE_HIGH (node
))
2551 pp_string (pp
, "case ");
2552 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2553 pp_string (pp
, " ... ");
2554 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2556 else if (CASE_LOW (node
))
2558 pp_string (pp
, "case ");
2559 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2562 pp_string (pp
, "default");
2567 pp_string (pp
, "OBJ_TYPE_REF(");
2568 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2570 if (!(flags
& TDF_SLIM
) && virtual_method_call_p (node
))
2572 pp_string (pp
, "(");
2573 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2574 pp_string (pp
, ")");
2576 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2578 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2579 pp_right_paren (pp
);
2583 if (SSA_NAME_IDENTIFIER (node
))
2584 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2587 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2588 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2589 pp_string (pp
, "(D)");
2590 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2591 pp_string (pp
, "(ab)");
2594 case WITH_SIZE_EXPR
:
2595 pp_string (pp
, "WITH_SIZE_EXPR <");
2596 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2597 pp_string (pp
, ", ");
2598 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2603 pp_string (pp
, "ASSERT_EXPR <");
2604 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2605 pp_string (pp
, ", ");
2606 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2611 pp_string (pp
, "scev_known");
2614 case SCEV_NOT_KNOWN
:
2615 pp_string (pp
, "scev_not_known");
2618 case POLYNOMIAL_CHREC
:
2620 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2621 pp_string (pp
, ", +, ");
2622 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2623 pp_string (pp
, "}_");
2624 dump_generic_node (pp
, CHREC_VAR (node
), spc
, flags
, false);
2628 case REALIGN_LOAD_EXPR
:
2629 pp_string (pp
, "REALIGN_LOAD <");
2630 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2631 pp_string (pp
, ", ");
2632 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2633 pp_string (pp
, ", ");
2634 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2639 pp_string (pp
, " VEC_COND_EXPR < ");
2640 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2641 pp_string (pp
, " , ");
2642 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2643 pp_string (pp
, " , ");
2644 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2645 pp_string (pp
, " > ");
2649 pp_string (pp
, " VEC_PERM_EXPR < ");
2650 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2651 pp_string (pp
, " , ");
2652 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2653 pp_string (pp
, " , ");
2654 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2655 pp_string (pp
, " > ");
2659 pp_string (pp
, " DOT_PROD_EXPR < ");
2660 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2661 pp_string (pp
, ", ");
2662 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2663 pp_string (pp
, ", ");
2664 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2665 pp_string (pp
, " > ");
2668 case WIDEN_MULT_PLUS_EXPR
:
2669 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
2670 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2671 pp_string (pp
, ", ");
2672 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2673 pp_string (pp
, ", ");
2674 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2675 pp_string (pp
, " > ");
2678 case WIDEN_MULT_MINUS_EXPR
:
2679 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
2680 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2681 pp_string (pp
, ", ");
2682 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2683 pp_string (pp
, ", ");
2684 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2685 pp_string (pp
, " > ");
2689 pp_string (pp
, " FMA_EXPR < ");
2690 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2691 pp_string (pp
, ", ");
2692 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2693 pp_string (pp
, ", ");
2694 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2695 pp_string (pp
, " > ");
2699 pp_string (pp
, "#pragma acc parallel");
2700 goto dump_omp_clauses_body
;
2703 pp_string (pp
, "#pragma acc kernels");
2704 goto dump_omp_clauses_body
;
2707 pp_string (pp
, "#pragma acc data");
2708 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2711 case OACC_HOST_DATA
:
2712 pp_string (pp
, "#pragma acc host_data");
2713 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2717 pp_string (pp
, "#pragma acc declare");
2718 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2722 pp_string (pp
, "#pragma acc update");
2723 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2726 case OACC_ENTER_DATA
:
2727 pp_string (pp
, "#pragma acc enter data");
2728 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2731 case OACC_EXIT_DATA
:
2732 pp_string (pp
, "#pragma acc exit data");
2733 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2737 pp_string (pp
, "#pragma acc cache");
2738 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2742 pp_string (pp
, "#pragma omp parallel");
2743 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2746 dump_omp_clauses_body
:
2747 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2751 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2753 newline_and_indent (pp
, spc
+ 2);
2755 newline_and_indent (pp
, spc
+ 4);
2756 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2757 newline_and_indent (pp
, spc
+ 2);
2758 pp_right_brace (pp
);
2764 pp_string (pp
, "#pragma omp task");
2765 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2769 pp_string (pp
, "#pragma omp for");
2773 pp_string (pp
, "#pragma omp simd");
2777 pp_string (pp
, "#pragma simd");
2781 /* This label points one line after dumping the clauses.
2782 For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2783 parameters are printed out. */
2784 goto dump_omp_loop_cilk_for
;
2786 case OMP_DISTRIBUTE
:
2787 pp_string (pp
, "#pragma omp distribute");
2791 pp_string (pp
, "#pragma omp taskloop");
2795 pp_string (pp
, "#pragma acc loop");
2799 pp_string (pp
, "#pragma omp teams");
2800 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
2803 case OMP_TARGET_DATA
:
2804 pp_string (pp
, "#pragma omp target data");
2805 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
2808 case OMP_TARGET_ENTER_DATA
:
2809 pp_string (pp
, "#pragma omp target enter data");
2810 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2814 case OMP_TARGET_EXIT_DATA
:
2815 pp_string (pp
, "#pragma omp target exit data");
2816 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2821 pp_string (pp
, "#pragma omp target");
2822 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
2825 case OMP_TARGET_UPDATE
:
2826 pp_string (pp
, "#pragma omp target update");
2827 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
2832 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2834 dump_omp_loop_cilk_for
:
2835 if (!(flags
& TDF_SLIM
))
2839 if (OMP_FOR_PRE_BODY (node
))
2841 if (TREE_CODE (node
) == CILK_FOR
)
2842 pp_string (pp
, " ");
2844 newline_and_indent (pp
, spc
+ 2);
2847 newline_and_indent (pp
, spc
);
2848 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
2851 if (OMP_FOR_INIT (node
))
2854 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
2857 if (TREE_CODE (node
) != CILK_FOR
|| OMP_FOR_PRE_BODY (node
))
2858 newline_and_indent (pp
, spc
);
2859 if (TREE_CODE (node
) == CILK_FOR
)
2860 pp_string (pp
, "_Cilk_for (");
2862 pp_string (pp
, "for (");
2863 dump_generic_node (pp
,
2864 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
2866 pp_string (pp
, "; ");
2867 dump_generic_node (pp
,
2868 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
2870 pp_string (pp
, "; ");
2871 dump_generic_node (pp
,
2872 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
2874 pp_right_paren (pp
);
2876 if (TREE_CODE (node
) == CILK_FOR
)
2877 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2879 if (OMP_FOR_BODY (node
))
2881 newline_and_indent (pp
, spc
+ 2);
2883 newline_and_indent (pp
, spc
+ 4);
2884 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
2886 newline_and_indent (pp
, spc
+ 2);
2887 pp_right_brace (pp
);
2889 if (OMP_FOR_INIT (node
))
2890 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
2891 if (OMP_FOR_PRE_BODY (node
))
2894 newline_and_indent (pp
, spc
+ 2);
2895 pp_right_brace (pp
);
2902 pp_string (pp
, "#pragma omp sections");
2903 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
2907 pp_string (pp
, "#pragma omp section");
2911 pp_string (pp
, "#pragma omp master");
2915 pp_string (pp
, "#pragma omp taskgroup");
2919 pp_string (pp
, "#pragma omp ordered");
2920 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
2924 pp_string (pp
, "#pragma omp critical");
2925 if (OMP_CRITICAL_NAME (node
))
2929 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
2931 pp_right_paren (pp
);
2933 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
2937 pp_string (pp
, "#pragma omp atomic");
2938 if (OMP_ATOMIC_SEQ_CST (node
))
2939 pp_string (pp
, " seq_cst");
2940 newline_and_indent (pp
, spc
+ 2);
2941 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2945 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2948 case OMP_ATOMIC_READ
:
2949 pp_string (pp
, "#pragma omp atomic read");
2950 if (OMP_ATOMIC_SEQ_CST (node
))
2951 pp_string (pp
, " seq_cst");
2952 newline_and_indent (pp
, spc
+ 2);
2953 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2957 case OMP_ATOMIC_CAPTURE_OLD
:
2958 case OMP_ATOMIC_CAPTURE_NEW
:
2959 pp_string (pp
, "#pragma omp atomic capture");
2960 if (OMP_ATOMIC_SEQ_CST (node
))
2961 pp_string (pp
, " seq_cst");
2962 newline_and_indent (pp
, spc
+ 2);
2963 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2967 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2971 pp_string (pp
, "#pragma omp single");
2972 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
2976 dump_omp_clause (pp
, node
, spc
, flags
);
2980 case TRANSACTION_EXPR
:
2981 if (TRANSACTION_EXPR_OUTER (node
))
2982 pp_string (pp
, "__transaction_atomic [[outer]]");
2983 else if (TRANSACTION_EXPR_RELAXED (node
))
2984 pp_string (pp
, "__transaction_relaxed");
2986 pp_string (pp
, "__transaction_atomic");
2987 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
2989 newline_and_indent (pp
, spc
);
2991 newline_and_indent (pp
, spc
+ 2);
2992 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
2993 spc
+ 2, flags
, false);
2994 newline_and_indent (pp
, spc
);
2995 pp_right_brace (pp
);
3000 case REDUC_MAX_EXPR
:
3001 pp_string (pp
, " REDUC_MAX_EXPR < ");
3002 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3003 pp_string (pp
, " > ");
3006 case REDUC_MIN_EXPR
:
3007 pp_string (pp
, " REDUC_MIN_EXPR < ");
3008 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3009 pp_string (pp
, " > ");
3012 case REDUC_PLUS_EXPR
:
3013 pp_string (pp
, " REDUC_PLUS_EXPR < ");
3014 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3015 pp_string (pp
, " > ");
3018 case VEC_WIDEN_MULT_HI_EXPR
:
3019 case VEC_WIDEN_MULT_LO_EXPR
:
3020 case VEC_WIDEN_MULT_EVEN_EXPR
:
3021 case VEC_WIDEN_MULT_ODD_EXPR
:
3022 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3023 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3025 for (str
= get_tree_code_name (code
); *str
; str
++)
3026 pp_character (pp
, TOUPPER (*str
));
3027 pp_string (pp
, " < ");
3028 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3029 pp_string (pp
, ", ");
3030 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3031 pp_string (pp
, " > ");
3034 case VEC_UNPACK_HI_EXPR
:
3035 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3036 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3037 pp_string (pp
, " > ");
3040 case VEC_UNPACK_LO_EXPR
:
3041 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3042 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3043 pp_string (pp
, " > ");
3046 case VEC_UNPACK_FLOAT_HI_EXPR
:
3047 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3048 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3049 pp_string (pp
, " > ");
3052 case VEC_UNPACK_FLOAT_LO_EXPR
:
3053 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3054 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3055 pp_string (pp
, " > ");
3058 case VEC_PACK_TRUNC_EXPR
:
3059 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3060 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3061 pp_string (pp
, ", ");
3062 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3063 pp_string (pp
, " > ");
3066 case VEC_PACK_SAT_EXPR
:
3067 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3068 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3069 pp_string (pp
, ", ");
3070 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3071 pp_string (pp
, " > ");
3074 case VEC_PACK_FIX_TRUNC_EXPR
:
3075 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3076 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3077 pp_string (pp
, ", ");
3078 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3079 pp_string (pp
, " > ");
3083 dump_block_node (pp
, node
, spc
, flags
);
3086 case CILK_SPAWN_STMT
:
3087 pp_string (pp
, "_Cilk_spawn ");
3088 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3091 case CILK_SYNC_STMT
:
3092 pp_string (pp
, "_Cilk_sync");
3099 if (is_stmt
&& is_expr
)
3105 /* Print the declaration of a variable. */
3108 print_declaration (pretty_printer
*pp
, tree t
, int spc
, int flags
)
3112 if (TREE_CODE(t
) == NAMELIST_DECL
)
3114 pp_string(pp
, "namelist ");
3115 dump_decl_name (pp
, t
, flags
);
3120 if (TREE_CODE (t
) == TYPE_DECL
)
3121 pp_string (pp
, "typedef ");
3123 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3124 pp_string (pp
, "register ");
3126 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3127 pp_string (pp
, "extern ");
3128 else if (TREE_STATIC (t
))
3129 pp_string (pp
, "static ");
3131 /* Print the type and name. */
3132 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3136 /* Print array's type. */
3137 tmp
= TREE_TYPE (t
);
3138 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3139 tmp
= TREE_TYPE (tmp
);
3140 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3142 /* Print variable's name. */
3144 dump_generic_node (pp
, t
, spc
, flags
, false);
3146 /* Print the dimensions. */
3147 tmp
= TREE_TYPE (t
);
3148 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3150 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3151 tmp
= TREE_TYPE (tmp
);
3154 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3156 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3158 dump_decl_name (pp
, t
, flags
);
3159 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3163 /* Print type declaration. */
3164 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3166 /* Print variable's name. */
3168 dump_generic_node (pp
, t
, spc
, flags
, false);
3171 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
3173 pp_string (pp
, " __asm__ ");
3175 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3176 pp_right_paren (pp
);
3179 /* The initial value of a function serves to determine whether the function
3180 is declared or defined. So the following does not apply to function
3182 if (TREE_CODE (t
) != FUNCTION_DECL
)
3184 /* Print the initial value. */
3185 if (DECL_INITIAL (t
))
3190 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3194 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
3196 pp_string (pp
, " [value-expr: ");
3197 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3198 pp_right_bracket (pp
);
3205 /* Prints a structure: name, fields, and methods.
3206 FIXME: Still incomplete. */
3209 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
, int flags
)
3211 /* Print the name of the structure. */
3212 if (TYPE_NAME (node
))
3215 if (TREE_CODE (node
) == RECORD_TYPE
)
3216 pp_string (pp
, "struct ");
3217 else if ((TREE_CODE (node
) == UNION_TYPE
3218 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3219 pp_string (pp
, "union ");
3221 dump_generic_node (pp
, TYPE_NAME (node
), spc
, 0, false);
3224 /* Print the contents of the structure. */
3230 /* Print the fields of the structure. */
3233 tmp
= TYPE_FIELDS (node
);
3236 /* Avoid to print recursively the structure. */
3237 /* FIXME : Not implemented correctly...,
3238 what about the case when we have a cycle in the contain graph? ...
3239 Maybe this could be solved by looking at the scope in which the
3240 structure was declared. */
3241 if (TREE_TYPE (tmp
) != node
3242 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3243 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3245 print_declaration (pp
, tmp
, spc
+2, flags
);
3248 tmp
= DECL_CHAIN (tmp
);
3252 pp_right_brace (pp
);
3255 /* Return the priority of the operator CODE.
3257 From lowest to highest precedence with either left-to-right (L-R)
3258 or right-to-left (R-L) associativity]:
3261 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3273 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3274 15 [L-R] fn() [] -> .
3276 unary +, - and * have higher precedence than the corresponding binary
3280 op_code_prio (enum tree_code code
)
3297 case TRUTH_ORIF_EXPR
:
3300 case TRUTH_AND_EXPR
:
3301 case TRUTH_ANDIF_EXPR
:
3308 case TRUTH_XOR_EXPR
:
3325 case UNORDERED_EXPR
:
3336 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3337 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3338 case WIDEN_LSHIFT_EXPR
:
3341 case WIDEN_SUM_EXPR
:
3343 case POINTER_PLUS_EXPR
:
3347 case VEC_WIDEN_MULT_HI_EXPR
:
3348 case VEC_WIDEN_MULT_LO_EXPR
:
3349 case WIDEN_MULT_EXPR
:
3351 case WIDEN_MULT_PLUS_EXPR
:
3352 case WIDEN_MULT_MINUS_EXPR
:
3354 case MULT_HIGHPART_EXPR
:
3355 case TRUNC_DIV_EXPR
:
3357 case FLOOR_DIV_EXPR
:
3358 case ROUND_DIV_EXPR
:
3360 case EXACT_DIV_EXPR
:
3361 case TRUNC_MOD_EXPR
:
3363 case FLOOR_MOD_EXPR
:
3364 case ROUND_MOD_EXPR
:
3368 case TRUTH_NOT_EXPR
:
3370 case POSTINCREMENT_EXPR
:
3371 case POSTDECREMENT_EXPR
:
3372 case PREINCREMENT_EXPR
:
3373 case PREDECREMENT_EXPR
:
3379 case FIX_TRUNC_EXPR
:
3385 case ARRAY_RANGE_REF
:
3389 /* Special expressions. */
3395 case REDUC_MAX_EXPR
:
3396 case REDUC_MIN_EXPR
:
3397 case REDUC_PLUS_EXPR
:
3398 case VEC_UNPACK_HI_EXPR
:
3399 case VEC_UNPACK_LO_EXPR
:
3400 case VEC_UNPACK_FLOAT_HI_EXPR
:
3401 case VEC_UNPACK_FLOAT_LO_EXPR
:
3402 case VEC_PACK_TRUNC_EXPR
:
3403 case VEC_PACK_SAT_EXPR
:
3407 /* Return an arbitrarily high precedence to avoid surrounding single
3408 VAR_DECLs in ()s. */
3413 /* Return the priority of the operator OP. */
3416 op_prio (const_tree op
)
3418 enum tree_code code
;
3423 code
= TREE_CODE (op
);
3424 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3425 return op_prio (TREE_OPERAND (op
, 0));
3427 return op_code_prio (code
);
3430 /* Return the symbol associated with operator CODE. */
3433 op_symbol_code (enum tree_code code
)
3441 case TRUTH_ORIF_EXPR
:
3444 case TRUTH_AND_EXPR
:
3445 case TRUTH_ANDIF_EXPR
:
3451 case TRUTH_XOR_EXPR
:
3461 case UNORDERED_EXPR
:
3507 case WIDEN_LSHIFT_EXPR
:
3510 case POINTER_PLUS_EXPR
:
3516 case REDUC_PLUS_EXPR
:
3519 case WIDEN_SUM_EXPR
:
3522 case WIDEN_MULT_EXPR
:
3525 case MULT_HIGHPART_EXPR
:
3535 case TRUTH_NOT_EXPR
:
3542 case TRUNC_DIV_EXPR
:
3549 case FLOOR_DIV_EXPR
:
3552 case ROUND_DIV_EXPR
:
3555 case EXACT_DIV_EXPR
:
3558 case TRUNC_MOD_EXPR
:
3564 case FLOOR_MOD_EXPR
:
3567 case ROUND_MOD_EXPR
:
3570 case PREDECREMENT_EXPR
:
3573 case PREINCREMENT_EXPR
:
3576 case POSTDECREMENT_EXPR
:
3579 case POSTINCREMENT_EXPR
:
3589 return "<<< ??? >>>";
3593 /* Return the symbol associated with operator OP. */
3596 op_symbol (const_tree op
)
3598 return op_symbol_code (TREE_CODE (op
));
3601 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3602 the gimple_call_fn of a GIMPLE_CALL. */
3605 print_call_name (pretty_printer
*pp
, tree node
, int flags
)
3609 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3610 op0
= TREE_OPERAND (op0
, 0);
3613 switch (TREE_CODE (op0
))
3618 dump_function_name (pp
, op0
, flags
);
3624 op0
= TREE_OPERAND (op0
, 0);
3629 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3630 pp_string (pp
, ") ? ");
3631 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3632 pp_string (pp
, " : ");
3633 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3637 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3638 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
3640 dump_generic_node (pp
, op0
, 0, flags
, false);
3644 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3646 op0
= TREE_OPERAND (op0
, 0);
3653 dump_generic_node (pp
, op0
, 0, flags
, false);
3661 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3664 pretty_print_string (pretty_printer
*pp
, const char *str
)
3674 pp_string (pp
, "\\b");
3678 pp_string (pp
, "\\f");
3682 pp_string (pp
, "\\n");
3686 pp_string (pp
, "\\r");
3690 pp_string (pp
, "\\t");
3694 pp_string (pp
, "\\v");
3698 pp_string (pp
, "\\\\");
3702 pp_string (pp
, "\\\"");
3706 pp_string (pp
, "\\'");
3709 /* No need to handle \0; the loop terminates on \0. */
3712 pp_string (pp
, "\\1");
3716 pp_string (pp
, "\\2");
3720 pp_string (pp
, "\\3");
3724 pp_string (pp
, "\\4");
3728 pp_string (pp
, "\\5");
3732 pp_string (pp
, "\\6");
3736 pp_string (pp
, "\\7");
3740 pp_character (pp
, str
[0]);
3748 maybe_init_pretty_print (FILE *file
)
3752 tree_pp
= new pretty_printer ();
3753 pp_needs_newline (tree_pp
) = true;
3754 pp_translate_identifiers (tree_pp
) = false;
3757 tree_pp
->buffer
->stream
= file
;
3761 newline_and_indent (pretty_printer
*pp
, int spc
)
3767 /* Handle a %K format for TEXT. Separate from default_tree_printer so
3768 it can also be used in front ends.
3769 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3773 percent_K_format (text_info
*text
)
3775 tree t
= va_arg (*text
->args_ptr
, tree
), block
;
3776 text
->set_location (0, EXPR_LOCATION (t
), true);
3777 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3778 block
= TREE_BLOCK (t
);
3779 *pp_ti_abstract_origin (text
) = NULL
;
3783 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3784 representing the outermost block of an inlined function.
3785 So walk the BLOCK tree until we hit such a scope. */
3787 && TREE_CODE (block
) == BLOCK
)
3789 if (inlined_function_outer_scope_p (block
))
3791 *pp_ti_abstract_origin (text
) = block
;
3794 block
= BLOCK_SUPERCONTEXT (block
);
3800 && TREE_CODE (block
) == BLOCK
3801 && BLOCK_ABSTRACT_ORIGIN (block
))
3803 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3805 while (TREE_CODE (ao
) == BLOCK
3806 && BLOCK_ABSTRACT_ORIGIN (ao
)
3807 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3808 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3810 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3812 *pp_ti_abstract_origin (text
) = block
;
3815 block
= BLOCK_SUPERCONTEXT (block
);
3819 /* Print the identifier ID to PRETTY-PRINTER. */
3822 pp_tree_identifier (pretty_printer
*pp
, tree id
)
3824 if (pp_translate_identifiers (pp
))
3826 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
3827 pp_append_text (pp
, text
, text
+ strlen (text
));
3830 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
3831 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
3834 /* A helper function that is used to dump function information before the
3838 dump_function_header (FILE *dump_file
, tree fdecl
, int flags
)
3840 const char *dname
, *aname
;
3841 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
3842 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
3844 dname
= lang_hooks
.decl_printable_name (fdecl
, 2);
3846 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
3847 aname
= (IDENTIFIER_POINTER
3848 (DECL_ASSEMBLER_NAME (fdecl
)));
3850 aname
= "<unset-asm-name>";
3852 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
3853 dname
, aname
, fun
->funcdef_no
);
3854 if (!(flags
& TDF_NOUID
))
3855 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
3858 fprintf (dump_file
, ", cgraph_uid=%d", node
->uid
);
3859 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
3860 node
->frequency
== NODE_FREQUENCY_HOT
3862 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
3863 ? " (unlikely executed)"
3864 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
3865 ? " (executed once)"
3869 fprintf (dump_file
, ")\n\n");
3872 /* Dump double_int D to pretty_printer PP. UNS is true
3873 if D is unsigned and false otherwise. */
3875 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
3878 pp_wide_integer (pp
, d
.low
);
3879 else if (d
.fits_uhwi ())
3880 pp_unsigned_wide_integer (pp
, d
.low
);
3883 unsigned HOST_WIDE_INT low
= d
.low
;
3884 HOST_WIDE_INT high
= d
.high
;
3885 if (!uns
&& d
.is_negative ())
3888 high
= ~high
+ !low
;
3891 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
3893 sprintf (pp_buffer (pp
)->digit_buffer
,
3894 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
3895 (unsigned HOST_WIDE_INT
) high
, low
);
3896 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);