1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2017 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
29 #include "tree-pretty-print.h"
30 #include "stor-layout.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
34 #include "internal-fn.h"
35 #include "gomp-constants.h"
38 /* Local functions, macros and variables. */
39 static const char *op_symbol (const_tree
);
40 static void pretty_print_string (pretty_printer
*, const char*);
41 static void newline_and_indent (pretty_printer
*, int);
42 static void maybe_init_pretty_print (FILE *);
43 static void print_struct_decl (pretty_printer
*, const_tree
, int, dump_flags_t
);
44 static void do_niy (pretty_printer
*, const_tree
, dump_flags_t
);
46 #define INDENT(SPACE) do { \
47 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
49 #define NIY do_niy (pp, node, flags)
51 static pretty_printer
*tree_pp
;
53 /* Try to print something for an unknown tree code. */
56 do_niy (pretty_printer
*pp
, const_tree node
, dump_flags_t flags
)
60 pp_string (pp
, "<<< Unknown tree: ");
61 pp_string (pp
, get_tree_code_name (TREE_CODE (node
)));
65 len
= TREE_OPERAND_LENGTH (node
);
66 for (i
= 0; i
< len
; ++i
)
68 newline_and_indent (pp
, 2);
69 dump_generic_node (pp
, TREE_OPERAND (node
, i
), 2, flags
, false);
73 pp_string (pp
, " >>>");
76 /* Debugging function to print out a generic expression. */
79 debug_generic_expr (tree t
)
81 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
82 fprintf (stderr
, "\n");
85 /* Debugging function to print out a generic statement. */
88 debug_generic_stmt (tree t
)
90 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
91 fprintf (stderr
, "\n");
94 /* Debugging function to print out a chain of trees . */
97 debug_tree_chain (tree t
)
103 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
104 fprintf (stderr
, " ");
108 fprintf (stderr
, "... [cycled back to ");
109 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
110 fprintf (stderr
, "]");
114 fprintf (stderr
, "\n");
117 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
119 print_generic_decl (FILE *file
, tree decl
, dump_flags_t flags
)
121 maybe_init_pretty_print (file
);
122 print_declaration (tree_pp
, decl
, 2, flags
);
123 pp_write_text_to_stream (tree_pp
);
126 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
127 to show in the dump. See TDF_* in dumpfile.h. */
130 print_generic_stmt (FILE *file
, tree t
, dump_flags_t flags
)
132 maybe_init_pretty_print (file
);
133 dump_generic_node (tree_pp
, t
, 0, flags
, true);
134 pp_newline_and_flush (tree_pp
);
137 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
138 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
142 print_generic_stmt_indented (FILE *file
, tree t
, dump_flags_t flags
, int indent
)
146 maybe_init_pretty_print (file
);
148 for (i
= 0; i
< indent
; i
++)
150 dump_generic_node (tree_pp
, t
, indent
, flags
, true);
151 pp_newline_and_flush (tree_pp
);
154 /* Print a single expression T on file FILE. FLAGS specifies details to show
155 in the dump. See TDF_* in dumpfile.h. */
158 print_generic_expr (FILE *file
, tree t
, dump_flags_t flags
)
160 maybe_init_pretty_print (file
);
161 dump_generic_node (tree_pp
, t
, 0, flags
, false);
165 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
166 in it are replaced with Dxxxx, as long as they are at the start or
167 preceded by $ and at the end or followed by $. See make_fancy_name
171 dump_fancy_name (pretty_printer
*pp
, tree name
)
174 int length
= IDENTIFIER_LENGTH (name
);
175 const char *n
= IDENTIFIER_POINTER (name
);
182 && (n
== IDENTIFIER_POINTER (name
) || n
[-1] == '$'))
185 while (ISDIGIT (n
[l
]))
187 if (n
[l
] == '\0' || n
[l
] == '$')
200 pp_tree_identifier (pp
, name
);
204 char *str
= XNEWVEC (char, length
+ 1);
207 q
= n
= IDENTIFIER_POINTER (name
);
214 && (q
== IDENTIFIER_POINTER (name
) || q
[-1] == '$'))
217 while (ISDIGIT (q
[l
]))
219 if (q
[l
] == '\0' || q
[l
] == '$')
221 memcpy (p
, n
, q
- n
);
222 memcpy (p
+ (q
- n
), "Dxxxx", 5);
232 memcpy (p
, n
, IDENTIFIER_LENGTH (name
) - (n
- IDENTIFIER_POINTER (name
)));
234 if (pp_translate_identifiers (pp
))
236 const char *text
= identifier_to_locale (str
);
237 pp_append_text (pp
, text
, text
+ strlen (text
));
240 pp_append_text (pp
, str
, str
+ length
);
244 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
248 dump_decl_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
250 if (DECL_NAME (node
))
252 if ((flags
& TDF_ASMNAME
)
253 && HAS_DECL_ASSEMBLER_NAME_P (node
)
254 && DECL_ASSEMBLER_NAME_SET_P (node
))
255 pp_tree_identifier (pp
, DECL_ASSEMBLER_NAME_RAW (node
));
256 /* For DECL_NAMELESS names look for embedded uids in the
257 names and sanitize them for TDF_NOUID. */
258 else if ((flags
& TDF_NOUID
) && DECL_NAMELESS (node
))
259 dump_fancy_name (pp
, DECL_NAME (node
));
261 pp_tree_identifier (pp
, DECL_NAME (node
));
263 char uid_sep
= (flags
& TDF_GIMPLE
) ? '_' : '.';
264 if ((flags
& TDF_UID
) || DECL_NAME (node
) == NULL_TREE
)
266 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
267 pp_printf (pp
, "L%c%d", uid_sep
, (int) LABEL_DECL_UID (node
));
268 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
270 if (flags
& TDF_NOUID
)
271 pp_string (pp
, "D#xxxx");
273 pp_printf (pp
, "D#%i", DEBUG_TEMP_UID (node
));
277 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
278 if (flags
& TDF_NOUID
)
279 pp_printf (pp
, "%c.xxxx", c
);
281 pp_printf (pp
, "%c%c%u", c
, uid_sep
, DECL_UID (node
));
284 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
286 if (flags
& TDF_NOUID
)
287 pp_printf (pp
, "ptD.xxxx");
289 pp_printf (pp
, "ptD.%u", DECL_PT_UID (node
));
293 /* Like the above, but used for pretty printing function calls. */
296 dump_function_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
298 if (CONVERT_EXPR_P (node
))
299 node
= TREE_OPERAND (node
, 0);
300 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
301 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
303 dump_decl_name (pp
, node
, flags
);
306 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
307 FLAGS are as in dump_generic_node. */
310 dump_function_declaration (pretty_printer
*pp
, tree node
,
311 int spc
, dump_flags_t flags
)
313 bool wrote_arg
= false;
319 /* Print the argument types. */
320 arg
= TYPE_ARG_TYPES (node
);
321 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
329 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
330 arg
= TREE_CHAIN (arg
);
333 /* Drop the trailing void_type_node if we had any previous argument. */
334 if (arg
== void_list_node
&& !wrote_arg
)
335 pp_string (pp
, "void");
336 /* Properly dump vararg function types. */
337 else if (!arg
&& wrote_arg
)
338 pp_string (pp
, ", ...");
339 /* Avoid printing any arg for unprototyped functions. */
344 /* Dump the domain associated with an array. */
347 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, dump_flags_t flags
)
349 pp_left_bracket (pp
);
352 tree min
= TYPE_MIN_VALUE (domain
);
353 tree max
= TYPE_MAX_VALUE (domain
);
356 && integer_zerop (min
)
357 && tree_fits_shwi_p (max
))
358 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
362 dump_generic_node (pp
, min
, spc
, flags
, false);
365 dump_generic_node (pp
, max
, spc
, flags
, false);
369 pp_string (pp
, "<unknown>");
370 pp_right_bracket (pp
);
374 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
375 dump_generic_node. */
378 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
382 switch (OMP_CLAUSE_CODE (clause
))
384 case OMP_CLAUSE_PRIVATE
:
387 case OMP_CLAUSE_SHARED
:
390 case OMP_CLAUSE_FIRSTPRIVATE
:
391 name
= "firstprivate";
393 case OMP_CLAUSE_LASTPRIVATE
:
394 name
= "lastprivate";
396 case OMP_CLAUSE_COPYIN
:
399 case OMP_CLAUSE_COPYPRIVATE
:
400 name
= "copyprivate";
402 case OMP_CLAUSE_UNIFORM
:
405 case OMP_CLAUSE_USE_DEVICE_PTR
:
406 name
= "use_device_ptr";
408 case OMP_CLAUSE_IS_DEVICE_PTR
:
409 name
= "is_device_ptr";
411 case OMP_CLAUSE__LOOPTEMP_
:
414 case OMP_CLAUSE_TO_DECLARE
:
417 case OMP_CLAUSE_LINK
:
421 pp_string (pp
, name
);
423 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
428 case OMP_CLAUSE_REDUCTION
:
429 pp_string (pp
, "reduction(");
430 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
433 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
436 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
442 pp_string (pp
, "if(");
443 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
445 case ERROR_MARK
: break;
446 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
447 case OMP_TASK
: pp_string (pp
, "task:"); break;
448 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
449 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
450 case OMP_TARGET
: pp_string (pp
, "target:"); break;
451 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
452 case OMP_TARGET_ENTER_DATA
:
453 pp_string (pp
, "target enter data:"); break;
454 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
455 default: gcc_unreachable ();
457 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
462 case OMP_CLAUSE_NUM_THREADS
:
463 pp_string (pp
, "num_threads(");
464 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
469 case OMP_CLAUSE__CILK_FOR_COUNT_
:
470 pp_string (pp
, "_Cilk_for_count_(");
471 dump_generic_node (pp
, OMP_CLAUSE_OPERAND (clause
, 0),
476 case OMP_CLAUSE_NOWAIT
:
477 pp_string (pp
, "nowait");
479 case OMP_CLAUSE_ORDERED
:
480 pp_string (pp
, "ordered");
481 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
484 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
490 case OMP_CLAUSE_DEFAULT
:
491 pp_string (pp
, "default(");
492 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
494 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
496 case OMP_CLAUSE_DEFAULT_SHARED
:
497 pp_string (pp
, "shared");
499 case OMP_CLAUSE_DEFAULT_NONE
:
500 pp_string (pp
, "none");
502 case OMP_CLAUSE_DEFAULT_PRIVATE
:
503 pp_string (pp
, "private");
505 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
506 pp_string (pp
, "firstprivate");
508 case OMP_CLAUSE_DEFAULT_PRESENT
:
509 pp_string (pp
, "present");
517 case OMP_CLAUSE_SCHEDULE
:
518 pp_string (pp
, "schedule(");
519 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
520 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
521 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
523 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
524 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
525 pp_string (pp
, "monotonic");
527 pp_string (pp
, "nonmonotonic");
528 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
533 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
534 pp_string (pp
, "simd:");
536 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
538 case OMP_CLAUSE_SCHEDULE_STATIC
:
539 pp_string (pp
, "static");
541 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
542 pp_string (pp
, "dynamic");
544 case OMP_CLAUSE_SCHEDULE_GUIDED
:
545 pp_string (pp
, "guided");
547 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
548 pp_string (pp
, "runtime");
550 case OMP_CLAUSE_SCHEDULE_AUTO
:
551 pp_string (pp
, "auto");
553 case OMP_CLAUSE_SCHEDULE_CILKFOR
:
554 pp_string (pp
, "cilk-for grain");
559 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
562 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
568 case OMP_CLAUSE_UNTIED
:
569 pp_string (pp
, "untied");
572 case OMP_CLAUSE_COLLAPSE
:
573 pp_string (pp
, "collapse(");
574 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
579 case OMP_CLAUSE_FINAL
:
580 pp_string (pp
, "final(");
581 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
586 case OMP_CLAUSE_MERGEABLE
:
587 pp_string (pp
, "mergeable");
590 case OMP_CLAUSE_LINEAR
:
591 pp_string (pp
, "linear(");
592 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
594 case OMP_CLAUSE_LINEAR_DEFAULT
:
596 case OMP_CLAUSE_LINEAR_REF
:
597 pp_string (pp
, "ref(");
599 case OMP_CLAUSE_LINEAR_VAL
:
600 pp_string (pp
, "val(");
602 case OMP_CLAUSE_LINEAR_UVAL
:
603 pp_string (pp
, "uval(");
608 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
610 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
613 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
618 case OMP_CLAUSE_ALIGNED
:
619 pp_string (pp
, "aligned(");
620 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
622 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
625 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
631 case OMP_CLAUSE_DEPEND
:
632 pp_string (pp
, "depend(");
633 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
635 case OMP_CLAUSE_DEPEND_IN
:
636 pp_string (pp
, "in");
638 case OMP_CLAUSE_DEPEND_OUT
:
639 pp_string (pp
, "out");
641 case OMP_CLAUSE_DEPEND_INOUT
:
642 pp_string (pp
, "inout");
644 case OMP_CLAUSE_DEPEND_SOURCE
:
645 pp_string (pp
, "source)");
647 case OMP_CLAUSE_DEPEND_SINK
:
648 pp_string (pp
, "sink:");
649 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
650 if (TREE_CODE (t
) == TREE_LIST
)
652 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
653 if (TREE_PURPOSE (t
) != integer_zero_node
)
655 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
659 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
673 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
679 pp_string (pp
, "map(");
680 switch (OMP_CLAUSE_MAP_KIND (clause
))
683 case GOMP_MAP_POINTER
:
684 pp_string (pp
, "alloc");
687 case GOMP_MAP_TO_PSET
:
688 pp_string (pp
, "to");
691 pp_string (pp
, "from");
693 case GOMP_MAP_TOFROM
:
694 pp_string (pp
, "tofrom");
696 case GOMP_MAP_FORCE_ALLOC
:
697 pp_string (pp
, "force_alloc");
699 case GOMP_MAP_FORCE_TO
:
700 pp_string (pp
, "force_to");
702 case GOMP_MAP_FORCE_FROM
:
703 pp_string (pp
, "force_from");
705 case GOMP_MAP_FORCE_TOFROM
:
706 pp_string (pp
, "force_tofrom");
708 case GOMP_MAP_FORCE_PRESENT
:
709 pp_string (pp
, "force_present");
711 case GOMP_MAP_DELETE
:
712 pp_string (pp
, "delete");
714 case GOMP_MAP_FORCE_DEVICEPTR
:
715 pp_string (pp
, "force_deviceptr");
717 case GOMP_MAP_ALWAYS_TO
:
718 pp_string (pp
, "always,to");
720 case GOMP_MAP_ALWAYS_FROM
:
721 pp_string (pp
, "always,from");
723 case GOMP_MAP_ALWAYS_TOFROM
:
724 pp_string (pp
, "always,tofrom");
726 case GOMP_MAP_RELEASE
:
727 pp_string (pp
, "release");
729 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
730 pp_string (pp
, "firstprivate");
732 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
733 pp_string (pp
, "firstprivate ref");
735 case GOMP_MAP_STRUCT
:
736 pp_string (pp
, "struct");
738 case GOMP_MAP_ALWAYS_POINTER
:
739 pp_string (pp
, "always_pointer");
741 case GOMP_MAP_DEVICE_RESIDENT
:
742 pp_string (pp
, "device_resident");
745 pp_string (pp
, "link");
751 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
754 if (OMP_CLAUSE_SIZE (clause
))
756 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
757 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
759 case GOMP_MAP_POINTER
:
760 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
761 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
762 case GOMP_MAP_ALWAYS_POINTER
:
763 pp_string (pp
, " [pointer assign, bias: ");
765 case GOMP_MAP_TO_PSET
:
766 pp_string (pp
, " [pointer set, len: ");
769 pp_string (pp
, " [len: ");
772 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
774 pp_right_bracket (pp
);
779 case OMP_CLAUSE_FROM
:
780 pp_string (pp
, "from(");
781 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
783 goto print_clause_size
;
786 pp_string (pp
, "to(");
787 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
789 goto print_clause_size
;
791 case OMP_CLAUSE__CACHE_
:
793 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
795 goto print_clause_size
;
797 case OMP_CLAUSE_NUM_TEAMS
:
798 pp_string (pp
, "num_teams(");
799 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
804 case OMP_CLAUSE_THREAD_LIMIT
:
805 pp_string (pp
, "thread_limit(");
806 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
811 case OMP_CLAUSE_DEVICE
:
812 pp_string (pp
, "device(");
813 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
818 case OMP_CLAUSE_DIST_SCHEDULE
:
819 pp_string (pp
, "dist_schedule(static");
820 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
823 dump_generic_node (pp
,
824 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
830 case OMP_CLAUSE_PROC_BIND
:
831 pp_string (pp
, "proc_bind(");
832 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
834 case OMP_CLAUSE_PROC_BIND_MASTER
:
835 pp_string (pp
, "master");
837 case OMP_CLAUSE_PROC_BIND_CLOSE
:
838 pp_string (pp
, "close");
840 case OMP_CLAUSE_PROC_BIND_SPREAD
:
841 pp_string (pp
, "spread");
849 case OMP_CLAUSE_SAFELEN
:
850 pp_string (pp
, "safelen(");
851 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
856 case OMP_CLAUSE_SIMDLEN
:
857 pp_string (pp
, "simdlen(");
858 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
863 case OMP_CLAUSE_PRIORITY
:
864 pp_string (pp
, "priority(");
865 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
870 case OMP_CLAUSE_GRAINSIZE
:
871 pp_string (pp
, "grainsize(");
872 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
877 case OMP_CLAUSE_NUM_TASKS
:
878 pp_string (pp
, "num_tasks(");
879 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
884 case OMP_CLAUSE_HINT
:
885 pp_string (pp
, "hint(");
886 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
891 case OMP_CLAUSE_DEFAULTMAP
:
892 pp_string (pp
, "defaultmap(tofrom:scalar)");
895 case OMP_CLAUSE__SIMDUID_
:
896 pp_string (pp
, "_simduid_(");
897 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
902 case OMP_CLAUSE__SIMT_
:
903 pp_string (pp
, "_simt_");
906 case OMP_CLAUSE_GANG
:
907 pp_string (pp
, "gang");
908 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
910 pp_string (pp
, "(num: ");
911 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
914 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
916 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
920 pp_string (pp
, "static:");
921 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
922 == integer_minus_one_node
)
923 pp_character (pp
, '*');
925 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
928 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
929 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
933 case OMP_CLAUSE_ASYNC
:
934 pp_string (pp
, "async");
935 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
937 pp_character(pp
, '(');
938 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
940 pp_character(pp
, ')');
944 case OMP_CLAUSE_AUTO
:
946 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
949 case OMP_CLAUSE_WAIT
:
950 pp_string (pp
, "wait(");
951 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
953 pp_character(pp
, ')');
956 case OMP_CLAUSE_WORKER
:
957 pp_string (pp
, "worker");
958 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
961 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
967 case OMP_CLAUSE_VECTOR
:
968 pp_string (pp
, "vector");
969 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
972 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
978 case OMP_CLAUSE_NUM_GANGS
:
979 pp_string (pp
, "num_gangs(");
980 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
982 pp_character (pp
, ')');
985 case OMP_CLAUSE_NUM_WORKERS
:
986 pp_string (pp
, "num_workers(");
987 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
989 pp_character (pp
, ')');
992 case OMP_CLAUSE_VECTOR_LENGTH
:
993 pp_string (pp
, "vector_length(");
994 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
996 pp_character (pp
, ')');
999 case OMP_CLAUSE_INBRANCH
:
1000 pp_string (pp
, "inbranch");
1002 case OMP_CLAUSE_NOTINBRANCH
:
1003 pp_string (pp
, "notinbranch");
1005 case OMP_CLAUSE_FOR
:
1006 pp_string (pp
, "for");
1008 case OMP_CLAUSE_PARALLEL
:
1009 pp_string (pp
, "parallel");
1011 case OMP_CLAUSE_SECTIONS
:
1012 pp_string (pp
, "sections");
1014 case OMP_CLAUSE_TASKGROUP
:
1015 pp_string (pp
, "taskgroup");
1017 case OMP_CLAUSE_NOGROUP
:
1018 pp_string (pp
, "nogroup");
1020 case OMP_CLAUSE_THREADS
:
1021 pp_string (pp
, "threads");
1023 case OMP_CLAUSE_SIMD
:
1024 pp_string (pp
, "simd");
1026 case OMP_CLAUSE_INDEPENDENT
:
1027 pp_string (pp
, "independent");
1029 case OMP_CLAUSE_TILE
:
1030 pp_string (pp
, "tile(");
1031 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1033 pp_right_paren (pp
);
1036 case OMP_CLAUSE__GRIDDIM_
:
1037 pp_string (pp
, "_griddim_(");
1038 pp_unsigned_wide_integer (pp
, OMP_CLAUSE__GRIDDIM__DIMENSION (clause
));
1040 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__SIZE (clause
), spc
, flags
,
1043 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__GROUP (clause
), spc
, flags
,
1045 pp_right_paren (pp
);
1049 /* Should never happen. */
1050 dump_generic_node (pp
, clause
, spc
, flags
, false);
1056 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1057 dump_generic_node. */
1060 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
1068 dump_omp_clause (pp
, clause
, spc
, flags
);
1069 clause
= OMP_CLAUSE_CHAIN (clause
);
1077 /* Dump location LOC to PP. */
1080 dump_location (pretty_printer
*pp
, location_t loc
)
1082 expanded_location xloc
= expand_location (loc
);
1084 pp_left_bracket (pp
);
1087 pp_string (pp
, xloc
.file
);
1088 pp_string (pp
, ":");
1090 pp_decimal_int (pp
, xloc
.line
);
1092 pp_decimal_int (pp
, xloc
.column
);
1093 pp_string (pp
, "] ");
1097 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1098 dump_generic_node. */
1101 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, dump_flags_t flags
)
1105 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1107 if (flags
& TDF_ADDRESS
)
1108 pp_printf (pp
, "[%p] ", (void *) block
);
1110 if (BLOCK_ABSTRACT (block
))
1111 pp_string (pp
, "[abstract] ");
1113 if (TREE_ASM_WRITTEN (block
))
1114 pp_string (pp
, "[written] ");
1116 if (flags
& TDF_SLIM
)
1119 if (BLOCK_SOURCE_LOCATION (block
))
1120 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1122 newline_and_indent (pp
, spc
+ 2);
1124 if (BLOCK_SUPERCONTEXT (block
))
1126 pp_string (pp
, "SUPERCONTEXT: ");
1127 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1128 flags
| TDF_SLIM
, false);
1129 newline_and_indent (pp
, spc
+ 2);
1132 if (BLOCK_SUBBLOCKS (block
))
1134 pp_string (pp
, "SUBBLOCKS: ");
1135 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1137 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1140 newline_and_indent (pp
, spc
+ 2);
1143 if (BLOCK_CHAIN (block
))
1145 pp_string (pp
, "SIBLINGS: ");
1146 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1148 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1151 newline_and_indent (pp
, spc
+ 2);
1154 if (BLOCK_VARS (block
))
1156 pp_string (pp
, "VARS: ");
1157 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1159 dump_generic_node (pp
, t
, 0, flags
, false);
1162 newline_and_indent (pp
, spc
+ 2);
1165 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1168 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1170 pp_string (pp
, "NONLOCALIZED_VARS: ");
1171 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1173 dump_generic_node (pp
, t
, 0, flags
, false);
1176 newline_and_indent (pp
, spc
+ 2);
1179 if (BLOCK_ABSTRACT_ORIGIN (block
))
1181 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1182 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1183 flags
| TDF_SLIM
, false);
1184 newline_and_indent (pp
, spc
+ 2);
1187 if (BLOCK_FRAGMENT_ORIGIN (block
))
1189 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1190 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1191 flags
| TDF_SLIM
, false);
1192 newline_and_indent (pp
, spc
+ 2);
1195 if (BLOCK_FRAGMENT_CHAIN (block
))
1197 pp_string (pp
, "FRAGMENT_CHAIN: ");
1198 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1200 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1203 newline_and_indent (pp
, spc
+ 2);
1208 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1209 indent. FLAGS specifies details to show in the dump (see TDF_* in
1210 dumpfile.h). If IS_STMT is true, the object printed is considered
1211 to be a statement and it is terminated by ';' if appropriate. */
1214 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
,
1221 enum tree_code code
;
1223 if (node
== NULL_TREE
)
1226 is_expr
= EXPR_P (node
);
1228 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1229 pp_printf (pp
, "<&%p> ", (void *)node
);
1231 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1232 dump_location (pp
, EXPR_LOCATION (node
));
1234 code
= TREE_CODE (node
);
1238 pp_string (pp
, "<<< error >>>");
1241 case IDENTIFIER_NODE
:
1242 pp_tree_identifier (pp
, node
);
1246 while (node
&& node
!= error_mark_node
)
1248 if (TREE_PURPOSE (node
))
1250 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1253 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1254 node
= TREE_CHAIN (node
);
1255 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1264 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1270 if (TREE_VEC_LENGTH (node
) > 0)
1272 size_t len
= TREE_VEC_LENGTH (node
);
1273 for (i
= 0; i
< len
- 1; i
++)
1275 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1280 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1287 case POINTER_BOUNDS_TYPE
:
1290 case FIXED_POINT_TYPE
:
1296 unsigned int quals
= TYPE_QUALS (node
);
1297 enum tree_code_class tclass
;
1299 if (quals
& TYPE_QUAL_ATOMIC
)
1300 pp_string (pp
, "atomic ");
1301 if (quals
& TYPE_QUAL_CONST
)
1302 pp_string (pp
, "const ");
1303 else if (quals
& TYPE_QUAL_VOLATILE
)
1304 pp_string (pp
, "volatile ");
1305 else if (quals
& TYPE_QUAL_RESTRICT
)
1306 pp_string (pp
, "restrict ");
1308 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1310 pp_string (pp
, "<address-space-");
1311 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1312 pp_string (pp
, "> ");
1315 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1317 if (tclass
== tcc_declaration
)
1319 if (DECL_NAME (node
))
1320 dump_decl_name (pp
, node
, flags
);
1322 pp_string (pp
, "<unnamed type decl>");
1324 else if (tclass
== tcc_type
)
1326 if (TYPE_NAME (node
))
1328 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1329 pp_tree_identifier (pp
, TYPE_NAME (node
));
1330 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1331 && DECL_NAME (TYPE_NAME (node
)))
1332 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1334 pp_string (pp
, "<unnamed type>");
1336 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1338 pp_string (pp
, "vector");
1340 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1341 pp_string (pp
, ") ");
1342 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1344 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1346 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1347 pp_string (pp
, (TYPE_UNSIGNED (node
)
1350 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1351 pp_string (pp
, (TYPE_UNSIGNED (node
)
1354 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1355 pp_string (pp
, (TYPE_UNSIGNED (node
)
1358 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1359 pp_string (pp
, (TYPE_UNSIGNED (node
)
1362 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1363 pp_string (pp
, (TYPE_UNSIGNED (node
)
1364 ? "unsigned long long"
1365 : "signed long long"));
1366 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1367 && pow2p_hwi (TYPE_PRECISION (node
)))
1369 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1370 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1371 pp_string (pp
, "_t");
1375 pp_string (pp
, (TYPE_UNSIGNED (node
)
1376 ? "<unnamed-unsigned:"
1377 : "<unnamed-signed:"));
1378 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1382 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1384 pp_string (pp
, "__complex__ ");
1385 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1387 else if (TREE_CODE (node
) == REAL_TYPE
)
1389 pp_string (pp
, "<float:");
1390 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1393 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1395 pp_string (pp
, "<fixed-point-");
1396 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1397 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1400 else if (TREE_CODE (node
) == VOID_TYPE
)
1401 pp_string (pp
, "void");
1403 pp_string (pp
, "<unnamed type>");
1409 case REFERENCE_TYPE
:
1410 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1412 if (TREE_TYPE (node
) == NULL
)
1414 pp_string (pp
, str
);
1415 pp_string (pp
, "<null type>");
1417 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1419 tree fnode
= TREE_TYPE (node
);
1421 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1424 pp_string (pp
, str
);
1425 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1426 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1427 else if (flags
& TDF_NOUID
)
1428 pp_printf (pp
, "<Txxxx>");
1430 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1432 pp_right_paren (pp
);
1433 dump_function_declaration (pp
, fnode
, spc
, flags
);
1437 unsigned int quals
= TYPE_QUALS (node
);
1439 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1441 pp_string (pp
, str
);
1443 if (quals
& TYPE_QUAL_CONST
)
1444 pp_string (pp
, " const");
1445 if (quals
& TYPE_QUAL_VOLATILE
)
1446 pp_string (pp
, " volatile");
1447 if (quals
& TYPE_QUAL_RESTRICT
)
1448 pp_string (pp
, " restrict");
1450 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1452 pp_string (pp
, " <address-space-");
1453 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1457 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1458 pp_string (pp
, " {ref-all}");
1468 if (flags
& TDF_GIMPLE
)
1470 pp_string (pp
, "__MEM <");
1471 dump_generic_node (pp
, TREE_TYPE (node
),
1472 spc
, flags
| TDF_SLIM
, false);
1473 if (TYPE_ALIGN (TREE_TYPE (node
))
1474 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
1476 pp_string (pp
, ", ");
1477 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
1480 pp_string (pp
, " (");
1481 if (TREE_TYPE (TREE_OPERAND (node
, 0))
1482 != TREE_TYPE (TREE_OPERAND (node
, 1)))
1485 dump_generic_node (pp
, TREE_TYPE (TREE_OPERAND (node
, 1)),
1486 spc
, flags
| TDF_SLIM
, false);
1487 pp_right_paren (pp
);
1489 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1490 spc
, flags
| TDF_SLIM
, false);
1491 if (! integer_zerop (TREE_OPERAND (node
, 1)))
1493 pp_string (pp
, " + ");
1494 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1495 spc
, flags
| TDF_SLIM
, false);
1497 pp_right_paren (pp
);
1499 else if (integer_zerop (TREE_OPERAND (node
, 1))
1500 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1501 infer them and MEM_ATTR caching will share MEM_REFs
1502 with differently-typed op0s. */
1503 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1504 /* Released SSA_NAMES have no TREE_TYPE. */
1505 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1506 /* Same pointer types, but ignoring POINTER_TYPE vs.
1508 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1509 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1510 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1511 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1512 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1513 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1514 /* Same value types ignoring qualifiers. */
1515 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1516 == TYPE_MAIN_VARIANT
1517 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1518 && (!(flags
& TDF_ALIAS
)
1519 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1521 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1524 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1528 dump_generic_node (pp
,
1529 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1536 pp_string (pp
, "MEM[");
1538 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1539 dump_generic_node (pp
, ptype
,
1540 spc
, flags
| TDF_SLIM
, false);
1541 pp_right_paren (pp
);
1542 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1544 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1546 pp_string (pp
, " + ");
1547 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1550 if ((flags
& TDF_ALIAS
)
1551 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1553 pp_string (pp
, " clique ");
1554 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1555 pp_string (pp
, " base ");
1556 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1558 pp_right_bracket (pp
);
1563 case TARGET_MEM_REF
:
1565 const char *sep
= "";
1568 pp_string (pp
, "MEM[");
1570 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1572 pp_string (pp
, sep
);
1574 pp_string (pp
, "symbol: ");
1575 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1580 pp_string (pp
, sep
);
1582 pp_string (pp
, "base: ");
1583 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1585 tmp
= TMR_INDEX2 (node
);
1588 pp_string (pp
, sep
);
1590 pp_string (pp
, "base: ");
1591 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1593 tmp
= TMR_INDEX (node
);
1596 pp_string (pp
, sep
);
1598 pp_string (pp
, "index: ");
1599 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1601 tmp
= TMR_STEP (node
);
1604 pp_string (pp
, sep
);
1606 pp_string (pp
, "step: ");
1607 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1609 tmp
= TMR_OFFSET (node
);
1612 pp_string (pp
, sep
);
1614 pp_string (pp
, "offset: ");
1615 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1617 pp_right_bracket (pp
);
1625 /* Print the innermost component type. */
1626 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1627 tmp
= TREE_TYPE (tmp
))
1629 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1631 /* Print the dimensions. */
1632 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1633 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1639 case QUAL_UNION_TYPE
:
1641 unsigned int quals
= TYPE_QUALS (node
);
1643 if (quals
& TYPE_QUAL_ATOMIC
)
1644 pp_string (pp
, "atomic ");
1645 if (quals
& TYPE_QUAL_CONST
)
1646 pp_string (pp
, "const ");
1647 if (quals
& TYPE_QUAL_VOLATILE
)
1648 pp_string (pp
, "volatile ");
1650 /* Print the name of the structure. */
1651 if (TREE_CODE (node
) == RECORD_TYPE
)
1652 pp_string (pp
, "struct ");
1653 else if (TREE_CODE (node
) == UNION_TYPE
)
1654 pp_string (pp
, "union ");
1656 if (TYPE_NAME (node
))
1657 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1658 else if (!(flags
& TDF_SLIM
))
1659 /* FIXME: If we eliminate the 'else' above and attempt
1660 to show the fields for named types, we may get stuck
1661 following a cycle of pointers to structs. The alleged
1662 self-reference check in print_struct_decl will not detect
1663 cycles involving more than one pointer or struct type. */
1664 print_struct_decl (pp
, node
, spc
, flags
);
1673 if (flags
& TDF_GIMPLE
1674 && (POINTER_TYPE_P (TREE_TYPE (node
))
1675 || (TYPE_PRECISION (TREE_TYPE (node
))
1676 < TYPE_PRECISION (integer_type_node
))
1677 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1679 pp_string (pp
, "_Literal (");
1680 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1681 pp_string (pp
, ") ");
1683 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
1684 && ! (flags
& TDF_GIMPLE
))
1686 /* In the case of a pointer, one may want to divide by the
1687 size of the pointed-to type. Unfortunately, this not
1688 straightforward. The C front-end maps expressions
1693 in such a way that the two INTEGER_CST nodes for "5" have
1694 different values but identical types. In the latter
1695 case, the 5 is multiplied by sizeof (int) in c-common.c
1696 (pointer_int_sum) to convert it to a byte address, and
1697 yet the type of the node is left unchanged. Argh. What
1698 is consistent though is that the number value corresponds
1699 to bytes (UNITS) offset.
1701 NB: Neither of the following divisors can be trivially
1702 used to recover the original literal:
1704 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1705 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1706 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1707 pp_string (pp
, "B"); /* pseudo-unit */
1709 else if (tree_fits_shwi_p (node
))
1710 pp_wide_integer (pp
, tree_to_shwi (node
));
1711 else if (tree_fits_uhwi_p (node
))
1712 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1715 wide_int val
= wi::to_wide (node
);
1717 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1722 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
1723 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
1725 if ((flags
& TDF_GIMPLE
)
1726 && ! (POINTER_TYPE_P (TREE_TYPE (node
))
1727 || (TYPE_PRECISION (TREE_TYPE (node
))
1728 < TYPE_PRECISION (integer_type_node
))
1729 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1731 if (TYPE_UNSIGNED (TREE_TYPE (node
)))
1732 pp_character (pp
, 'u');
1733 if (TYPE_PRECISION (TREE_TYPE (node
))
1734 == TYPE_PRECISION (unsigned_type_node
))
1736 else if (TYPE_PRECISION (TREE_TYPE (node
))
1737 == TYPE_PRECISION (long_unsigned_type_node
))
1738 pp_character (pp
, 'l');
1739 else if (TYPE_PRECISION (TREE_TYPE (node
))
1740 == TYPE_PRECISION (long_long_unsigned_type_node
))
1741 pp_string (pp
, "ll");
1743 if (TREE_OVERFLOW (node
))
1744 pp_string (pp
, "(OVF)");
1748 /* Code copied from print_node. */
1751 if (TREE_OVERFLOW (node
))
1752 pp_string (pp
, " overflow");
1754 d
= TREE_REAL_CST (node
);
1755 if (REAL_VALUE_ISINF (d
))
1756 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1757 else if (REAL_VALUE_ISNAN (d
))
1758 pp_string (pp
, " Nan");
1762 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1763 pp_string (pp
, string
);
1771 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1772 pp_string (pp
, string
);
1777 pp_string (pp
, "__complex__ (");
1778 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
1779 pp_string (pp
, ", ");
1780 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
1781 pp_right_paren (pp
);
1785 pp_string (pp
, "\"");
1786 pretty_print_string (pp
, TREE_STRING_POINTER (node
));
1787 pp_string (pp
, "\"");
1793 pp_string (pp
, "{ ");
1794 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1797 pp_string (pp
, ", ");
1798 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
1801 pp_string (pp
, " }");
1807 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1809 if (TREE_CODE (node
) == METHOD_TYPE
)
1811 if (TYPE_METHOD_BASETYPE (node
))
1812 dump_decl_name (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1815 pp_string (pp
, "<null method basetype>");
1816 pp_colon_colon (pp
);
1818 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1819 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1820 else if (flags
& TDF_NOUID
)
1821 pp_printf (pp
, "<Txxxx>");
1823 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1824 dump_function_declaration (pp
, node
, spc
, flags
);
1829 dump_decl_name (pp
, node
, flags
);
1833 if (DECL_NAME (node
))
1834 dump_decl_name (pp
, node
, flags
);
1835 else if (LABEL_DECL_UID (node
) != -1)
1837 if (flags
& TDF_GIMPLE
)
1838 pp_printf (pp
, "L%d", (int) LABEL_DECL_UID (node
));
1840 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
1844 if (flags
& TDF_NOUID
)
1845 pp_string (pp
, "<D.xxxx>");
1848 if (flags
& TDF_GIMPLE
)
1849 pp_printf (pp
, "<D%u>", DECL_UID (node
));
1851 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
1857 if (DECL_IS_BUILTIN (node
))
1859 /* Don't print the declaration of built-in types. */
1862 if (DECL_NAME (node
))
1863 dump_decl_name (pp
, node
, flags
);
1864 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1866 pp_string (pp
, (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1867 ? "union" : "struct "));
1868 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1871 pp_string (pp
, "<anon>");
1877 case DEBUG_EXPR_DECL
:
1878 case NAMESPACE_DECL
:
1880 dump_decl_name (pp
, node
, flags
);
1884 pp_string (pp
, "<retval>");
1888 op0
= TREE_OPERAND (node
, 0);
1891 && (TREE_CODE (op0
) == INDIRECT_REF
1892 || (TREE_CODE (op0
) == MEM_REF
1893 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1894 && integer_zerop (TREE_OPERAND (op0
, 1))
1895 /* Dump the types of INTEGER_CSTs explicitly, for we
1896 can't infer them and MEM_ATTR caching will share
1897 MEM_REFs with differently-typed op0s. */
1898 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1899 /* Released SSA_NAMES have no TREE_TYPE. */
1900 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1901 /* Same pointer types, but ignoring POINTER_TYPE vs.
1903 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1904 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1905 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1906 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1907 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1908 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1909 /* Same value types ignoring qualifiers. */
1910 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1911 == TYPE_MAIN_VARIANT
1912 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
1913 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
1915 op0
= TREE_OPERAND (op0
, 0);
1918 if (op_prio (op0
) < op_prio (node
))
1920 dump_generic_node (pp
, op0
, spc
, flags
, false);
1921 if (op_prio (op0
) < op_prio (node
))
1922 pp_right_paren (pp
);
1923 pp_string (pp
, str
);
1924 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1925 op0
= component_ref_field_offset (node
);
1926 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1928 pp_string (pp
, "{off: ");
1929 dump_generic_node (pp
, op0
, spc
, flags
, false);
1930 pp_right_brace (pp
);
1935 pp_string (pp
, "BIT_FIELD_REF <");
1936 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1937 pp_string (pp
, ", ");
1938 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1939 pp_string (pp
, ", ");
1940 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1944 case BIT_INSERT_EXPR
:
1945 pp_string (pp
, "BIT_INSERT_EXPR <");
1946 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1947 pp_string (pp
, ", ");
1948 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1949 pp_string (pp
, ", ");
1950 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1951 pp_string (pp
, " (");
1952 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
1954 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
1956 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
1958 pp_string (pp
, " bits)>");
1962 case ARRAY_RANGE_REF
:
1963 op0
= TREE_OPERAND (node
, 0);
1964 if (op_prio (op0
) < op_prio (node
))
1966 dump_generic_node (pp
, op0
, spc
, flags
, false);
1967 if (op_prio (op0
) < op_prio (node
))
1968 pp_right_paren (pp
);
1969 pp_left_bracket (pp
);
1970 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1971 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1972 pp_string (pp
, " ...");
1973 pp_right_bracket (pp
);
1975 op0
= array_ref_low_bound (node
);
1976 op1
= array_ref_element_size (node
);
1978 if (!integer_zerop (op0
)
1979 || TREE_OPERAND (node
, 2)
1980 || TREE_OPERAND (node
, 3))
1982 pp_string (pp
, "{lb: ");
1983 dump_generic_node (pp
, op0
, spc
, flags
, false);
1984 pp_string (pp
, " sz: ");
1985 dump_generic_node (pp
, op1
, spc
, flags
, false);
1986 pp_right_brace (pp
);
1992 unsigned HOST_WIDE_INT ix
;
1994 bool is_struct_init
= false;
1995 bool is_array_init
= false;
1998 if (TREE_CLOBBER_P (node
))
1999 pp_string (pp
, "CLOBBER");
2000 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
2001 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
2002 is_struct_init
= true;
2003 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
2004 && TYPE_DOMAIN (TREE_TYPE (node
))
2005 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
2006 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
2009 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
2010 is_array_init
= true;
2011 curidx
= wi::to_widest (minv
);
2013 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
2020 dump_generic_node (pp
, field
, spc
, flags
, false);
2023 else if (is_array_init
2024 && (TREE_CODE (field
) != INTEGER_CST
2025 || curidx
!= wi::to_widest (field
)))
2027 pp_left_bracket (pp
);
2028 if (TREE_CODE (field
) == RANGE_EXPR
)
2030 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
2032 pp_string (pp
, " ... ");
2033 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
2035 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
2036 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
2039 dump_generic_node (pp
, field
, spc
, flags
, false);
2040 if (TREE_CODE (field
) == INTEGER_CST
)
2041 curidx
= wi::to_widest (field
);
2042 pp_string (pp
, "]=");
2047 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
2048 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
2049 val
= TREE_OPERAND (val
, 0);
2050 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
2051 dump_decl_name (pp
, val
, flags
);
2053 dump_generic_node (pp
, val
, spc
, flags
, false);
2054 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2060 pp_right_brace (pp
);
2067 if (flags
& TDF_SLIM
)
2069 pp_string (pp
, "<COMPOUND_EXPR>");
2073 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2074 spc
, flags
, !(flags
& TDF_SLIM
));
2075 if (flags
& TDF_SLIM
)
2076 newline_and_indent (pp
, spc
);
2083 for (tp
= &TREE_OPERAND (node
, 1);
2084 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2085 tp
= &TREE_OPERAND (*tp
, 1))
2087 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2088 spc
, flags
, !(flags
& TDF_SLIM
));
2089 if (flags
& TDF_SLIM
)
2090 newline_and_indent (pp
, spc
);
2098 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2102 case STATEMENT_LIST
:
2104 tree_stmt_iterator si
;
2107 if (flags
& TDF_SLIM
)
2109 pp_string (pp
, "<STATEMENT_LIST>");
2113 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2116 newline_and_indent (pp
, spc
);
2119 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2126 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2131 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2136 pp_string (pp
, "TARGET_EXPR <");
2137 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2140 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2145 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2150 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2152 pp_string (pp
, "if (");
2153 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2154 pp_right_paren (pp
);
2155 /* The lowered cond_exprs should always be printed in full. */
2156 if (COND_EXPR_THEN (node
)
2157 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2158 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2159 && COND_EXPR_ELSE (node
)
2160 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2161 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2164 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2166 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2168 pp_string (pp
, " else ");
2169 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2173 else if (!(flags
& TDF_SLIM
))
2175 /* Output COND_EXPR_THEN. */
2176 if (COND_EXPR_THEN (node
))
2178 newline_and_indent (pp
, spc
+2);
2180 newline_and_indent (pp
, spc
+4);
2181 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2183 newline_and_indent (pp
, spc
+2);
2184 pp_right_brace (pp
);
2187 /* Output COND_EXPR_ELSE. */
2188 if (COND_EXPR_ELSE (node
)
2189 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2191 newline_and_indent (pp
, spc
);
2192 pp_string (pp
, "else");
2193 newline_and_indent (pp
, spc
+2);
2195 newline_and_indent (pp
, spc
+4);
2196 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2198 newline_and_indent (pp
, spc
+2);
2199 pp_right_brace (pp
);
2206 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2210 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2214 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2220 if (!(flags
& TDF_SLIM
))
2222 if (BIND_EXPR_VARS (node
))
2226 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2228 print_declaration (pp
, op0
, spc
+2, flags
);
2233 newline_and_indent (pp
, spc
+2);
2234 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2235 newline_and_indent (pp
, spc
);
2236 pp_right_brace (pp
);
2242 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2243 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2245 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2247 /* Print parameters. */
2252 call_expr_arg_iterator iter
;
2253 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2255 dump_generic_node (pp
, arg
, spc
, flags
, false);
2256 if (more_call_expr_args_p (&iter
))
2263 if (CALL_EXPR_VA_ARG_PACK (node
))
2265 if (call_expr_nargs (node
) > 0)
2270 pp_string (pp
, "__builtin_va_arg_pack ()");
2272 pp_right_paren (pp
);
2274 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2277 pp_string (pp
, " [static-chain: ");
2278 dump_generic_node (pp
, op1
, spc
, flags
, false);
2279 pp_right_bracket (pp
);
2282 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2283 pp_string (pp
, " [return slot optimization]");
2284 if (CALL_EXPR_TAILCALL (node
))
2285 pp_string (pp
, " [tail call]");
2288 case WITH_CLEANUP_EXPR
:
2292 case CLEANUP_POINT_EXPR
:
2293 pp_string (pp
, "<<cleanup_point ");
2294 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2295 pp_string (pp
, ">>");
2298 case PLACEHOLDER_EXPR
:
2299 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2300 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2304 /* Binary arithmetic and logic expressions. */
2305 case WIDEN_SUM_EXPR
:
2306 case WIDEN_MULT_EXPR
:
2308 case MULT_HIGHPART_EXPR
:
2310 case POINTER_PLUS_EXPR
:
2311 case POINTER_DIFF_EXPR
:
2313 case TRUNC_DIV_EXPR
:
2315 case FLOOR_DIV_EXPR
:
2316 case ROUND_DIV_EXPR
:
2317 case TRUNC_MOD_EXPR
:
2319 case FLOOR_MOD_EXPR
:
2320 case ROUND_MOD_EXPR
:
2322 case EXACT_DIV_EXPR
:
2327 case WIDEN_LSHIFT_EXPR
:
2331 case TRUTH_ANDIF_EXPR
:
2332 case TRUTH_ORIF_EXPR
:
2333 case TRUTH_AND_EXPR
:
2335 case TRUTH_XOR_EXPR
:
2349 case UNORDERED_EXPR
:
2351 const char *op
= op_symbol (node
);
2352 op0
= TREE_OPERAND (node
, 0);
2353 op1
= TREE_OPERAND (node
, 1);
2355 /* When the operands are expressions with less priority,
2356 keep semantics of the tree representation. */
2357 if (op_prio (op0
) <= op_prio (node
))
2360 dump_generic_node (pp
, op0
, spc
, flags
, false);
2361 pp_right_paren (pp
);
2364 dump_generic_node (pp
, op0
, spc
, flags
, false);
2370 /* When the operands are expressions with less priority,
2371 keep semantics of the tree representation. */
2372 if (op_prio (op1
) <= op_prio (node
))
2375 dump_generic_node (pp
, op1
, spc
, flags
, false);
2376 pp_right_paren (pp
);
2379 dump_generic_node (pp
, op1
, spc
, flags
, false);
2383 /* Unary arithmetic and logic expressions. */
2386 case TRUTH_NOT_EXPR
:
2388 case PREDECREMENT_EXPR
:
2389 case PREINCREMENT_EXPR
:
2391 if (TREE_CODE (node
) == ADDR_EXPR
2392 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2393 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2394 ; /* Do not output '&' for strings and function pointers. */
2396 pp_string (pp
, op_symbol (node
));
2398 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2401 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2402 pp_right_paren (pp
);
2405 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2408 case POSTDECREMENT_EXPR
:
2409 case POSTINCREMENT_EXPR
:
2410 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2413 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2414 pp_right_paren (pp
);
2417 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2418 pp_string (pp
, op_symbol (node
));
2422 pp_string (pp
, "MIN_EXPR <");
2423 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2424 pp_string (pp
, ", ");
2425 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2430 pp_string (pp
, "MAX_EXPR <");
2431 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2432 pp_string (pp
, ", ");
2433 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2438 pp_string (pp
, "ABS_EXPR <");
2439 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2447 case ADDR_SPACE_CONVERT_EXPR
:
2448 case FIXED_CONVERT_EXPR
:
2449 case FIX_TRUNC_EXPR
:
2452 type
= TREE_TYPE (node
);
2453 op0
= TREE_OPERAND (node
, 0);
2454 if (type
!= TREE_TYPE (op0
))
2457 dump_generic_node (pp
, type
, spc
, flags
, false);
2458 pp_string (pp
, ") ");
2460 if (op_prio (op0
) < op_prio (node
))
2462 dump_generic_node (pp
, op0
, spc
, flags
, false);
2463 if (op_prio (op0
) < op_prio (node
))
2464 pp_right_paren (pp
);
2467 case VIEW_CONVERT_EXPR
:
2468 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2469 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2470 pp_string (pp
, ">(");
2471 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2472 pp_right_paren (pp
);
2476 pp_string (pp
, "((");
2477 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2478 pp_string (pp
, "))");
2481 case NON_LVALUE_EXPR
:
2482 pp_string (pp
, "NON_LVALUE_EXPR <");
2483 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2488 pp_string (pp
, "SAVE_EXPR <");
2489 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2494 pp_string (pp
, "COMPLEX_EXPR <");
2495 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2496 pp_string (pp
, ", ");
2497 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2502 pp_string (pp
, "CONJ_EXPR <");
2503 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2508 if (flags
& TDF_GIMPLE
)
2510 pp_string (pp
, "__real ");
2511 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2515 pp_string (pp
, "REALPART_EXPR <");
2516 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2522 if (flags
& TDF_GIMPLE
)
2524 pp_string (pp
, "__imag ");
2525 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2529 pp_string (pp
, "IMAGPART_EXPR <");
2530 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2536 pp_string (pp
, "VA_ARG_EXPR <");
2537 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2541 case TRY_FINALLY_EXPR
:
2542 case TRY_CATCH_EXPR
:
2543 pp_string (pp
, "try");
2544 newline_and_indent (pp
, spc
+2);
2546 newline_and_indent (pp
, spc
+4);
2547 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2548 newline_and_indent (pp
, spc
+2);
2549 pp_right_brace (pp
);
2550 newline_and_indent (pp
, spc
);
2552 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2553 newline_and_indent (pp
, spc
+2);
2555 newline_and_indent (pp
, spc
+4);
2556 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2557 newline_and_indent (pp
, spc
+2);
2558 pp_right_brace (pp
);
2563 pp_string (pp
, "catch (");
2564 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2565 pp_right_paren (pp
);
2566 newline_and_indent (pp
, spc
+2);
2568 newline_and_indent (pp
, spc
+4);
2569 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2570 newline_and_indent (pp
, spc
+2);
2571 pp_right_brace (pp
);
2575 case EH_FILTER_EXPR
:
2576 pp_string (pp
, "<<<eh_filter (");
2577 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2578 pp_string (pp
, ")>>>");
2579 newline_and_indent (pp
, spc
+2);
2581 newline_and_indent (pp
, spc
+4);
2582 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2583 newline_and_indent (pp
, spc
+2);
2584 pp_right_brace (pp
);
2589 op0
= TREE_OPERAND (node
, 0);
2590 /* If this is for break or continue, don't bother printing it. */
2591 if (DECL_NAME (op0
))
2593 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2594 if (strcmp (name
, "break") == 0
2595 || strcmp (name
, "continue") == 0)
2598 dump_generic_node (pp
, op0
, spc
, flags
, false);
2600 if (DECL_NONLOCAL (op0
))
2601 pp_string (pp
, " [non-local]");
2605 pp_string (pp
, "while (1)");
2606 if (!(flags
& TDF_SLIM
))
2608 newline_and_indent (pp
, spc
+2);
2610 newline_and_indent (pp
, spc
+4);
2611 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2612 newline_and_indent (pp
, spc
+2);
2613 pp_right_brace (pp
);
2619 pp_string (pp
, "// predicted ");
2620 if (PREDICT_EXPR_OUTCOME (node
))
2621 pp_string (pp
, "likely by ");
2623 pp_string (pp
, "unlikely by ");
2624 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2625 pp_string (pp
, " predictor.");
2629 pp_string (pp
, "ANNOTATE_EXPR <");
2630 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2631 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2633 case annot_expr_ivdep_kind
:
2634 pp_string (pp
, ", ivdep");
2636 case annot_expr_unroll_kind
:
2637 pp_printf (pp
, ", unroll %d",
2638 (int) TREE_INT_CST_LOW (TREE_OPERAND (node
, 2)));
2640 case annot_expr_no_vector_kind
:
2641 pp_string (pp
, ", no-vector");
2643 case annot_expr_vector_kind
:
2644 pp_string (pp
, ", vector");
2646 case annot_expr_parallel_kind
:
2647 pp_string (pp
, ", parallel");
2656 pp_string (pp
, "return");
2657 op0
= TREE_OPERAND (node
, 0);
2661 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2662 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2665 dump_generic_node (pp
, op0
, spc
, flags
, false);
2670 pp_string (pp
, "if (");
2671 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2672 pp_string (pp
, ") break");
2676 pp_string (pp
, "switch (");
2677 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2678 pp_right_paren (pp
);
2679 if (!(flags
& TDF_SLIM
))
2681 newline_and_indent (pp
, spc
+2);
2683 if (SWITCH_BODY (node
))
2685 newline_and_indent (pp
, spc
+4);
2686 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2689 newline_and_indent (pp
, spc
+2);
2690 pp_right_brace (pp
);
2696 op0
= GOTO_DESTINATION (node
);
2697 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2699 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2700 if (strcmp (name
, "break") == 0
2701 || strcmp (name
, "continue") == 0)
2703 pp_string (pp
, name
);
2707 pp_string (pp
, "goto ");
2708 dump_generic_node (pp
, op0
, spc
, flags
, false);
2712 pp_string (pp
, "__asm__");
2713 if (ASM_VOLATILE_P (node
))
2714 pp_string (pp
, " __volatile__");
2716 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2718 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2720 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2721 if (ASM_CLOBBERS (node
))
2724 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2726 pp_right_paren (pp
);
2729 case CASE_LABEL_EXPR
:
2730 if (CASE_LOW (node
) && CASE_HIGH (node
))
2732 pp_string (pp
, "case ");
2733 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2734 pp_string (pp
, " ... ");
2735 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2737 else if (CASE_LOW (node
))
2739 pp_string (pp
, "case ");
2740 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2743 pp_string (pp
, "default");
2748 pp_string (pp
, "OBJ_TYPE_REF(");
2749 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2751 /* We omit the class type for -fcompare-debug because we may
2752 drop TYPE_BINFO early depending on debug info, and then
2753 virtual_method_call_p would return false, whereas when
2754 TYPE_BINFO is preserved it may still return true and then
2755 we'd print the class type. Compare tree and rtl dumps for
2756 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
2757 for example, at occurrences of OBJ_TYPE_REF. */
2758 if (!(flags
& (TDF_SLIM
| TDF_COMPARE_DEBUG
))
2759 && virtual_method_call_p (node
))
2761 pp_string (pp
, "(");
2762 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2763 pp_string (pp
, ")");
2765 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2767 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2768 pp_right_paren (pp
);
2772 if (SSA_NAME_IDENTIFIER (node
))
2774 if ((flags
& TDF_NOUID
)
2775 && SSA_NAME_VAR (node
)
2776 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
2777 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
2778 else if (! (flags
& TDF_GIMPLE
)
2779 || SSA_NAME_VAR (node
))
2780 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2784 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2785 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2786 pp_string (pp
, "(D)");
2787 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2788 pp_string (pp
, "(ab)");
2791 case WITH_SIZE_EXPR
:
2792 pp_string (pp
, "WITH_SIZE_EXPR <");
2793 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2794 pp_string (pp
, ", ");
2795 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2800 pp_string (pp
, "ASSERT_EXPR <");
2801 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2802 pp_string (pp
, ", ");
2803 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2808 pp_string (pp
, "scev_known");
2811 case SCEV_NOT_KNOWN
:
2812 pp_string (pp
, "scev_not_known");
2815 case POLYNOMIAL_CHREC
:
2817 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2818 pp_string (pp
, ", +, ");
2819 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2820 pp_printf (pp
, "}_%u", CHREC_VARIABLE (node
));
2824 case REALIGN_LOAD_EXPR
:
2825 pp_string (pp
, "REALIGN_LOAD <");
2826 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2827 pp_string (pp
, ", ");
2828 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2829 pp_string (pp
, ", ");
2830 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2835 pp_string (pp
, " VEC_COND_EXPR < ");
2836 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2837 pp_string (pp
, " , ");
2838 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2839 pp_string (pp
, " , ");
2840 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2841 pp_string (pp
, " > ");
2845 pp_string (pp
, " VEC_PERM_EXPR < ");
2846 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2847 pp_string (pp
, " , ");
2848 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2849 pp_string (pp
, " , ");
2850 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2851 pp_string (pp
, " > ");
2855 pp_string (pp
, " DOT_PROD_EXPR < ");
2856 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2857 pp_string (pp
, ", ");
2858 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2859 pp_string (pp
, ", ");
2860 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2861 pp_string (pp
, " > ");
2864 case WIDEN_MULT_PLUS_EXPR
:
2865 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
2866 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2867 pp_string (pp
, ", ");
2868 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2869 pp_string (pp
, ", ");
2870 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2871 pp_string (pp
, " > ");
2874 case WIDEN_MULT_MINUS_EXPR
:
2875 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
2876 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2877 pp_string (pp
, ", ");
2878 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2879 pp_string (pp
, ", ");
2880 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2881 pp_string (pp
, " > ");
2885 pp_string (pp
, " FMA_EXPR < ");
2886 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2887 pp_string (pp
, ", ");
2888 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2889 pp_string (pp
, ", ");
2890 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2891 pp_string (pp
, " > ");
2895 pp_string (pp
, "#pragma acc parallel");
2896 goto dump_omp_clauses_body
;
2899 pp_string (pp
, "#pragma acc kernels");
2900 goto dump_omp_clauses_body
;
2903 pp_string (pp
, "#pragma acc data");
2904 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2907 case OACC_HOST_DATA
:
2908 pp_string (pp
, "#pragma acc host_data");
2909 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2913 pp_string (pp
, "#pragma acc declare");
2914 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2918 pp_string (pp
, "#pragma acc update");
2919 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2922 case OACC_ENTER_DATA
:
2923 pp_string (pp
, "#pragma acc enter data");
2924 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2927 case OACC_EXIT_DATA
:
2928 pp_string (pp
, "#pragma acc exit data");
2929 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2933 pp_string (pp
, "#pragma acc cache");
2934 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2938 pp_string (pp
, "#pragma omp parallel");
2939 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2942 dump_omp_clauses_body
:
2943 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2947 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2949 newline_and_indent (pp
, spc
+ 2);
2951 newline_and_indent (pp
, spc
+ 4);
2952 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2953 newline_and_indent (pp
, spc
+ 2);
2954 pp_right_brace (pp
);
2960 pp_string (pp
, "#pragma omp task");
2961 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2965 pp_string (pp
, "#pragma omp for");
2969 pp_string (pp
, "#pragma omp simd");
2973 pp_string (pp
, "#pragma simd");
2977 /* This label points one line after dumping the clauses.
2978 For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2979 parameters are printed out. */
2980 goto dump_omp_loop_cilk_for
;
2982 case OMP_DISTRIBUTE
:
2983 pp_string (pp
, "#pragma omp distribute");
2987 pp_string (pp
, "#pragma omp taskloop");
2991 pp_string (pp
, "#pragma acc loop");
2995 pp_string (pp
, "#pragma omp teams");
2996 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
2999 case OMP_TARGET_DATA
:
3000 pp_string (pp
, "#pragma omp target data");
3001 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
3004 case OMP_TARGET_ENTER_DATA
:
3005 pp_string (pp
, "#pragma omp target enter data");
3006 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3010 case OMP_TARGET_EXIT_DATA
:
3011 pp_string (pp
, "#pragma omp target exit data");
3012 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3017 pp_string (pp
, "#pragma omp target");
3018 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3021 case OMP_TARGET_UPDATE
:
3022 pp_string (pp
, "#pragma omp target update");
3023 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3028 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3030 dump_omp_loop_cilk_for
:
3031 if (!(flags
& TDF_SLIM
))
3035 if (OMP_FOR_PRE_BODY (node
))
3037 if (TREE_CODE (node
) == CILK_FOR
)
3038 pp_string (pp
, " ");
3040 newline_and_indent (pp
, spc
+ 2);
3043 newline_and_indent (pp
, spc
);
3044 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3047 if (OMP_FOR_INIT (node
))
3050 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3053 if (TREE_CODE (node
) != CILK_FOR
|| OMP_FOR_PRE_BODY (node
))
3054 newline_and_indent (pp
, spc
);
3055 if (TREE_CODE (node
) == CILK_FOR
)
3056 pp_string (pp
, "_Cilk_for (");
3058 pp_string (pp
, "for (");
3059 dump_generic_node (pp
,
3060 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
3062 pp_string (pp
, "; ");
3063 dump_generic_node (pp
,
3064 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
3066 pp_string (pp
, "; ");
3067 dump_generic_node (pp
,
3068 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3070 pp_right_paren (pp
);
3072 if (TREE_CODE (node
) == CILK_FOR
)
3073 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3075 if (OMP_FOR_BODY (node
))
3077 newline_and_indent (pp
, spc
+ 2);
3079 newline_and_indent (pp
, spc
+ 4);
3080 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3082 newline_and_indent (pp
, spc
+ 2);
3083 pp_right_brace (pp
);
3085 if (OMP_FOR_INIT (node
))
3086 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3087 if (OMP_FOR_PRE_BODY (node
))
3090 newline_and_indent (pp
, spc
+ 2);
3091 pp_right_brace (pp
);
3098 pp_string (pp
, "#pragma omp sections");
3099 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3103 pp_string (pp
, "#pragma omp section");
3107 pp_string (pp
, "#pragma omp master");
3111 pp_string (pp
, "#pragma omp taskgroup");
3115 pp_string (pp
, "#pragma omp ordered");
3116 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3120 pp_string (pp
, "#pragma omp critical");
3121 if (OMP_CRITICAL_NAME (node
))
3125 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3127 pp_right_paren (pp
);
3129 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3133 pp_string (pp
, "#pragma omp atomic");
3134 if (OMP_ATOMIC_SEQ_CST (node
))
3135 pp_string (pp
, " seq_cst");
3136 newline_and_indent (pp
, spc
+ 2);
3137 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3141 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3144 case OMP_ATOMIC_READ
:
3145 pp_string (pp
, "#pragma omp atomic read");
3146 if (OMP_ATOMIC_SEQ_CST (node
))
3147 pp_string (pp
, " seq_cst");
3148 newline_and_indent (pp
, spc
+ 2);
3149 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3153 case OMP_ATOMIC_CAPTURE_OLD
:
3154 case OMP_ATOMIC_CAPTURE_NEW
:
3155 pp_string (pp
, "#pragma omp atomic capture");
3156 if (OMP_ATOMIC_SEQ_CST (node
))
3157 pp_string (pp
, " seq_cst");
3158 newline_and_indent (pp
, spc
+ 2);
3159 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3163 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3167 pp_string (pp
, "#pragma omp single");
3168 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3172 dump_omp_clause (pp
, node
, spc
, flags
);
3176 case TRANSACTION_EXPR
:
3177 if (TRANSACTION_EXPR_OUTER (node
))
3178 pp_string (pp
, "__transaction_atomic [[outer]]");
3179 else if (TRANSACTION_EXPR_RELAXED (node
))
3180 pp_string (pp
, "__transaction_relaxed");
3182 pp_string (pp
, "__transaction_atomic");
3183 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3185 newline_and_indent (pp
, spc
);
3187 newline_and_indent (pp
, spc
+ 2);
3188 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3189 spc
+ 2, flags
, false);
3190 newline_and_indent (pp
, spc
);
3191 pp_right_brace (pp
);
3196 case VEC_WIDEN_MULT_HI_EXPR
:
3197 case VEC_WIDEN_MULT_LO_EXPR
:
3198 case VEC_WIDEN_MULT_EVEN_EXPR
:
3199 case VEC_WIDEN_MULT_ODD_EXPR
:
3200 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3201 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3203 for (str
= get_tree_code_name (code
); *str
; str
++)
3204 pp_character (pp
, TOUPPER (*str
));
3205 pp_string (pp
, " < ");
3206 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3207 pp_string (pp
, ", ");
3208 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3209 pp_string (pp
, " > ");
3212 case VEC_UNPACK_HI_EXPR
:
3213 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3214 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3215 pp_string (pp
, " > ");
3218 case VEC_UNPACK_LO_EXPR
:
3219 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3220 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3221 pp_string (pp
, " > ");
3224 case VEC_UNPACK_FLOAT_HI_EXPR
:
3225 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3226 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3227 pp_string (pp
, " > ");
3230 case VEC_UNPACK_FLOAT_LO_EXPR
:
3231 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3232 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3233 pp_string (pp
, " > ");
3236 case VEC_PACK_TRUNC_EXPR
:
3237 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3238 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3239 pp_string (pp
, ", ");
3240 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3241 pp_string (pp
, " > ");
3244 case VEC_PACK_SAT_EXPR
:
3245 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3246 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3247 pp_string (pp
, ", ");
3248 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3249 pp_string (pp
, " > ");
3252 case VEC_PACK_FIX_TRUNC_EXPR
:
3253 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3254 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3255 pp_string (pp
, ", ");
3256 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3257 pp_string (pp
, " > ");
3261 dump_block_node (pp
, node
, spc
, flags
);
3264 case CILK_SPAWN_STMT
:
3265 pp_string (pp
, "_Cilk_spawn ");
3266 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3269 case CILK_SYNC_STMT
:
3270 pp_string (pp
, "_Cilk_sync");
3277 if (is_stmt
&& is_expr
)
3283 /* Print the declaration of a variable. */
3286 print_declaration (pretty_printer
*pp
, tree t
, int spc
, dump_flags_t flags
)
3290 if (TREE_CODE(t
) == NAMELIST_DECL
)
3292 pp_string(pp
, "namelist ");
3293 dump_decl_name (pp
, t
, flags
);
3298 if (TREE_CODE (t
) == TYPE_DECL
)
3299 pp_string (pp
, "typedef ");
3301 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3302 pp_string (pp
, "register ");
3304 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3305 pp_string (pp
, "extern ");
3306 else if (TREE_STATIC (t
))
3307 pp_string (pp
, "static ");
3309 /* Print the type and name. */
3310 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3314 /* Print array's type. */
3315 tmp
= TREE_TYPE (t
);
3316 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3317 tmp
= TREE_TYPE (tmp
);
3318 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3320 /* Print variable's name. */
3322 dump_generic_node (pp
, t
, spc
, flags
, false);
3324 /* Print the dimensions. */
3325 tmp
= TREE_TYPE (t
);
3326 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3328 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3329 tmp
= TREE_TYPE (tmp
);
3332 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3334 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3336 dump_decl_name (pp
, t
, flags
);
3337 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3341 /* Print type declaration. */
3342 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3344 /* Print variable's name. */
3346 dump_generic_node (pp
, t
, spc
, flags
, false);
3349 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
3351 pp_string (pp
, " __asm__ ");
3353 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3354 pp_right_paren (pp
);
3357 /* The initial value of a function serves to determine whether the function
3358 is declared or defined. So the following does not apply to function
3360 if (TREE_CODE (t
) != FUNCTION_DECL
)
3362 /* Print the initial value. */
3363 if (DECL_INITIAL (t
))
3368 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3372 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3374 pp_string (pp
, " [value-expr: ");
3375 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3376 pp_right_bracket (pp
);
3383 /* Prints a structure: name, fields, and methods.
3384 FIXME: Still incomplete. */
3387 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
3390 /* Print the name of the structure. */
3391 if (TYPE_NAME (node
))
3394 if (TREE_CODE (node
) == RECORD_TYPE
)
3395 pp_string (pp
, "struct ");
3396 else if ((TREE_CODE (node
) == UNION_TYPE
3397 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3398 pp_string (pp
, "union ");
3400 dump_generic_node (pp
, TYPE_NAME (node
), spc
, 0, false);
3403 /* Print the contents of the structure. */
3409 /* Print the fields of the structure. */
3412 tmp
= TYPE_FIELDS (node
);
3415 /* Avoid to print recursively the structure. */
3416 /* FIXME : Not implemented correctly...,
3417 what about the case when we have a cycle in the contain graph? ...
3418 Maybe this could be solved by looking at the scope in which the
3419 structure was declared. */
3420 if (TREE_TYPE (tmp
) != node
3421 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3422 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3424 print_declaration (pp
, tmp
, spc
+2, flags
);
3427 tmp
= DECL_CHAIN (tmp
);
3431 pp_right_brace (pp
);
3434 /* Return the priority of the operator CODE.
3436 From lowest to highest precedence with either left-to-right (L-R)
3437 or right-to-left (R-L) associativity]:
3440 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3452 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3453 15 [L-R] fn() [] -> .
3455 unary +, - and * have higher precedence than the corresponding binary
3459 op_code_prio (enum tree_code code
)
3476 case TRUTH_ORIF_EXPR
:
3479 case TRUTH_AND_EXPR
:
3480 case TRUTH_ANDIF_EXPR
:
3487 case TRUTH_XOR_EXPR
:
3504 case UNORDERED_EXPR
:
3515 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3516 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3517 case WIDEN_LSHIFT_EXPR
:
3520 case WIDEN_SUM_EXPR
:
3522 case POINTER_PLUS_EXPR
:
3523 case POINTER_DIFF_EXPR
:
3527 case VEC_WIDEN_MULT_HI_EXPR
:
3528 case VEC_WIDEN_MULT_LO_EXPR
:
3529 case WIDEN_MULT_EXPR
:
3531 case WIDEN_MULT_PLUS_EXPR
:
3532 case WIDEN_MULT_MINUS_EXPR
:
3534 case MULT_HIGHPART_EXPR
:
3535 case TRUNC_DIV_EXPR
:
3537 case FLOOR_DIV_EXPR
:
3538 case ROUND_DIV_EXPR
:
3540 case EXACT_DIV_EXPR
:
3541 case TRUNC_MOD_EXPR
:
3543 case FLOOR_MOD_EXPR
:
3544 case ROUND_MOD_EXPR
:
3548 case TRUTH_NOT_EXPR
:
3550 case POSTINCREMENT_EXPR
:
3551 case POSTDECREMENT_EXPR
:
3552 case PREINCREMENT_EXPR
:
3553 case PREDECREMENT_EXPR
:
3559 case FIX_TRUNC_EXPR
:
3565 case ARRAY_RANGE_REF
:
3569 /* Special expressions. */
3575 case VEC_UNPACK_HI_EXPR
:
3576 case VEC_UNPACK_LO_EXPR
:
3577 case VEC_UNPACK_FLOAT_HI_EXPR
:
3578 case VEC_UNPACK_FLOAT_LO_EXPR
:
3579 case VEC_PACK_TRUNC_EXPR
:
3580 case VEC_PACK_SAT_EXPR
:
3584 /* Return an arbitrarily high precedence to avoid surrounding single
3585 VAR_DECLs in ()s. */
3590 /* Return the priority of the operator OP. */
3593 op_prio (const_tree op
)
3595 enum tree_code code
;
3600 code
= TREE_CODE (op
);
3601 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3602 return op_prio (TREE_OPERAND (op
, 0));
3604 return op_code_prio (code
);
3607 /* Return the symbol associated with operator CODE. */
3610 op_symbol_code (enum tree_code code
)
3618 case TRUTH_ORIF_EXPR
:
3621 case TRUTH_AND_EXPR
:
3622 case TRUTH_ANDIF_EXPR
:
3628 case TRUTH_XOR_EXPR
:
3638 case UNORDERED_EXPR
:
3684 case WIDEN_LSHIFT_EXPR
:
3687 case POINTER_PLUS_EXPR
:
3693 case WIDEN_SUM_EXPR
:
3696 case WIDEN_MULT_EXPR
:
3699 case MULT_HIGHPART_EXPR
:
3704 case POINTER_DIFF_EXPR
:
3710 case TRUTH_NOT_EXPR
:
3717 case TRUNC_DIV_EXPR
:
3724 case FLOOR_DIV_EXPR
:
3727 case ROUND_DIV_EXPR
:
3730 case EXACT_DIV_EXPR
:
3733 case TRUNC_MOD_EXPR
:
3739 case FLOOR_MOD_EXPR
:
3742 case ROUND_MOD_EXPR
:
3745 case PREDECREMENT_EXPR
:
3748 case PREINCREMENT_EXPR
:
3751 case POSTDECREMENT_EXPR
:
3754 case POSTINCREMENT_EXPR
:
3764 return "<<< ??? >>>";
3768 /* Return the symbol associated with operator OP. */
3771 op_symbol (const_tree op
)
3773 return op_symbol_code (TREE_CODE (op
));
3776 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3777 the gimple_call_fn of a GIMPLE_CALL. */
3780 print_call_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
3784 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3785 op0
= TREE_OPERAND (op0
, 0);
3788 switch (TREE_CODE (op0
))
3793 dump_function_name (pp
, op0
, flags
);
3799 op0
= TREE_OPERAND (op0
, 0);
3804 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3805 pp_string (pp
, ") ? ");
3806 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3807 pp_string (pp
, " : ");
3808 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3812 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3813 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
3815 dump_generic_node (pp
, op0
, 0, flags
, false);
3819 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3821 op0
= TREE_OPERAND (op0
, 0);
3828 dump_generic_node (pp
, op0
, 0, flags
, false);
3836 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3839 pretty_print_string (pretty_printer
*pp
, const char *str
)
3849 pp_string (pp
, "\\b");
3853 pp_string (pp
, "\\f");
3857 pp_string (pp
, "\\n");
3861 pp_string (pp
, "\\r");
3865 pp_string (pp
, "\\t");
3869 pp_string (pp
, "\\v");
3873 pp_string (pp
, "\\\\");
3877 pp_string (pp
, "\\\"");
3881 pp_string (pp
, "\\'");
3884 /* No need to handle \0; the loop terminates on \0. */
3887 pp_string (pp
, "\\1");
3891 pp_string (pp
, "\\2");
3895 pp_string (pp
, "\\3");
3899 pp_string (pp
, "\\4");
3903 pp_string (pp
, "\\5");
3907 pp_string (pp
, "\\6");
3911 pp_string (pp
, "\\7");
3915 if (!ISPRINT (str
[0]))
3918 sprintf (buf
, "\\x%x", (unsigned char)str
[0]);
3919 pp_string (pp
, buf
);
3922 pp_character (pp
, str
[0]);
3930 maybe_init_pretty_print (FILE *file
)
3934 tree_pp
= new pretty_printer ();
3935 pp_needs_newline (tree_pp
) = true;
3936 pp_translate_identifiers (tree_pp
) = false;
3939 tree_pp
->buffer
->stream
= file
;
3943 newline_and_indent (pretty_printer
*pp
, int spc
)
3949 /* Handle the %K format for TEXT. Separate from default_tree_printer
3950 so it can also be used in front ends.
3951 Argument is a statement from which EXPR_LOCATION and TREE_BLOCK will
3955 percent_K_format (text_info
*text
, tree t
)
3957 text
->set_location (0, EXPR_LOCATION (t
), true);
3958 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3959 tree block
= TREE_BLOCK (t
);
3960 *pp_ti_abstract_origin (text
) = NULL
;
3964 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3965 representing the outermost block of an inlined function.
3966 So walk the BLOCK tree until we hit such a scope. */
3968 && TREE_CODE (block
) == BLOCK
)
3970 if (inlined_function_outer_scope_p (block
))
3972 *pp_ti_abstract_origin (text
) = block
;
3975 block
= BLOCK_SUPERCONTEXT (block
);
3981 && TREE_CODE (block
) == BLOCK
3982 && BLOCK_ABSTRACT_ORIGIN (block
))
3984 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3986 while (TREE_CODE (ao
) == BLOCK
3987 && BLOCK_ABSTRACT_ORIGIN (ao
)
3988 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3989 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3991 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3993 *pp_ti_abstract_origin (text
) = block
;
3996 block
= BLOCK_SUPERCONTEXT (block
);
4000 /* Print the identifier ID to PRETTY-PRINTER. */
4003 pp_tree_identifier (pretty_printer
*pp
, tree id
)
4005 if (pp_translate_identifiers (pp
))
4007 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
4008 pp_append_text (pp
, text
, text
+ strlen (text
));
4011 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
4012 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
4015 /* A helper function that is used to dump function information before the
4019 dump_function_header (FILE *dump_file
, tree fdecl
, dump_flags_t flags
)
4021 const char *dname
, *aname
;
4022 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
4023 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
4025 dname
= lang_hooks
.decl_printable_name (fdecl
, 1);
4027 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
4028 aname
= (IDENTIFIER_POINTER
4029 (DECL_ASSEMBLER_NAME (fdecl
)));
4031 aname
= "<unset-asm-name>";
4033 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
4034 dname
, aname
, fun
->funcdef_no
);
4035 if (!(flags
& TDF_NOUID
))
4036 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
4039 fprintf (dump_file
, ", cgraph_uid=%d", node
->uid
);
4040 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
4041 node
->frequency
== NODE_FREQUENCY_HOT
4043 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
4044 ? " (unlikely executed)"
4045 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
4046 ? " (executed once)"
4050 fprintf (dump_file
, ")\n\n");
4053 /* Dump double_int D to pretty_printer PP. UNS is true
4054 if D is unsigned and false otherwise. */
4056 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4059 pp_wide_integer (pp
, d
.low
);
4060 else if (d
.fits_uhwi ())
4061 pp_unsigned_wide_integer (pp
, d
.low
);
4064 unsigned HOST_WIDE_INT low
= d
.low
;
4065 HOST_WIDE_INT high
= d
.high
;
4066 if (!uns
&& d
.is_negative ())
4069 high
= ~high
+ !low
;
4072 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4074 sprintf (pp_buffer (pp
)->digit_buffer
,
4075 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4076 (unsigned HOST_WIDE_INT
) high
, low
);
4077 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);