1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2018 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_NOWAIT
:
470 pp_string (pp
, "nowait");
472 case OMP_CLAUSE_ORDERED
:
473 pp_string (pp
, "ordered");
474 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
477 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
483 case OMP_CLAUSE_DEFAULT
:
484 pp_string (pp
, "default(");
485 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
487 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
489 case OMP_CLAUSE_DEFAULT_SHARED
:
490 pp_string (pp
, "shared");
492 case OMP_CLAUSE_DEFAULT_NONE
:
493 pp_string (pp
, "none");
495 case OMP_CLAUSE_DEFAULT_PRIVATE
:
496 pp_string (pp
, "private");
498 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
499 pp_string (pp
, "firstprivate");
501 case OMP_CLAUSE_DEFAULT_PRESENT
:
502 pp_string (pp
, "present");
510 case OMP_CLAUSE_SCHEDULE
:
511 pp_string (pp
, "schedule(");
512 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
513 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
514 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
516 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
517 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
518 pp_string (pp
, "monotonic");
520 pp_string (pp
, "nonmonotonic");
521 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
526 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
527 pp_string (pp
, "simd:");
529 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
531 case OMP_CLAUSE_SCHEDULE_STATIC
:
532 pp_string (pp
, "static");
534 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
535 pp_string (pp
, "dynamic");
537 case OMP_CLAUSE_SCHEDULE_GUIDED
:
538 pp_string (pp
, "guided");
540 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
541 pp_string (pp
, "runtime");
543 case OMP_CLAUSE_SCHEDULE_AUTO
:
544 pp_string (pp
, "auto");
549 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
552 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
558 case OMP_CLAUSE_UNTIED
:
559 pp_string (pp
, "untied");
562 case OMP_CLAUSE_COLLAPSE
:
563 pp_string (pp
, "collapse(");
564 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
569 case OMP_CLAUSE_FINAL
:
570 pp_string (pp
, "final(");
571 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
576 case OMP_CLAUSE_MERGEABLE
:
577 pp_string (pp
, "mergeable");
580 case OMP_CLAUSE_LINEAR
:
581 pp_string (pp
, "linear(");
582 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
584 case OMP_CLAUSE_LINEAR_DEFAULT
:
586 case OMP_CLAUSE_LINEAR_REF
:
587 pp_string (pp
, "ref(");
589 case OMP_CLAUSE_LINEAR_VAL
:
590 pp_string (pp
, "val(");
592 case OMP_CLAUSE_LINEAR_UVAL
:
593 pp_string (pp
, "uval(");
598 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
600 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
603 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
608 case OMP_CLAUSE_ALIGNED
:
609 pp_string (pp
, "aligned(");
610 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
612 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
615 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
621 case OMP_CLAUSE_DEPEND
:
622 pp_string (pp
, "depend(");
623 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
625 case OMP_CLAUSE_DEPEND_IN
:
626 pp_string (pp
, "in");
628 case OMP_CLAUSE_DEPEND_OUT
:
629 pp_string (pp
, "out");
631 case OMP_CLAUSE_DEPEND_INOUT
:
632 pp_string (pp
, "inout");
634 case OMP_CLAUSE_DEPEND_SOURCE
:
635 pp_string (pp
, "source)");
637 case OMP_CLAUSE_DEPEND_SINK
:
638 pp_string (pp
, "sink:");
639 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
640 if (TREE_CODE (t
) == TREE_LIST
)
642 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
643 if (TREE_PURPOSE (t
) != integer_zero_node
)
645 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
649 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
663 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
669 pp_string (pp
, "map(");
670 switch (OMP_CLAUSE_MAP_KIND (clause
))
673 case GOMP_MAP_POINTER
:
674 pp_string (pp
, "alloc");
677 case GOMP_MAP_TO_PSET
:
678 pp_string (pp
, "to");
681 pp_string (pp
, "from");
683 case GOMP_MAP_TOFROM
:
684 pp_string (pp
, "tofrom");
686 case GOMP_MAP_FORCE_ALLOC
:
687 pp_string (pp
, "force_alloc");
689 case GOMP_MAP_FORCE_TO
:
690 pp_string (pp
, "force_to");
692 case GOMP_MAP_FORCE_FROM
:
693 pp_string (pp
, "force_from");
695 case GOMP_MAP_FORCE_TOFROM
:
696 pp_string (pp
, "force_tofrom");
698 case GOMP_MAP_FORCE_PRESENT
:
699 pp_string (pp
, "force_present");
701 case GOMP_MAP_DELETE
:
702 pp_string (pp
, "delete");
704 case GOMP_MAP_FORCE_DEVICEPTR
:
705 pp_string (pp
, "force_deviceptr");
707 case GOMP_MAP_ALWAYS_TO
:
708 pp_string (pp
, "always,to");
710 case GOMP_MAP_ALWAYS_FROM
:
711 pp_string (pp
, "always,from");
713 case GOMP_MAP_ALWAYS_TOFROM
:
714 pp_string (pp
, "always,tofrom");
716 case GOMP_MAP_RELEASE
:
717 pp_string (pp
, "release");
719 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
720 pp_string (pp
, "firstprivate");
722 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
723 pp_string (pp
, "firstprivate ref");
725 case GOMP_MAP_STRUCT
:
726 pp_string (pp
, "struct");
728 case GOMP_MAP_ALWAYS_POINTER
:
729 pp_string (pp
, "always_pointer");
731 case GOMP_MAP_DEVICE_RESIDENT
:
732 pp_string (pp
, "device_resident");
735 pp_string (pp
, "link");
741 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
744 if (OMP_CLAUSE_SIZE (clause
))
746 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
747 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
749 case GOMP_MAP_POINTER
:
750 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
751 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
752 case GOMP_MAP_ALWAYS_POINTER
:
753 pp_string (pp
, " [pointer assign, bias: ");
755 case GOMP_MAP_TO_PSET
:
756 pp_string (pp
, " [pointer set, len: ");
759 pp_string (pp
, " [len: ");
762 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
764 pp_right_bracket (pp
);
769 case OMP_CLAUSE_FROM
:
770 pp_string (pp
, "from(");
771 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
773 goto print_clause_size
;
776 pp_string (pp
, "to(");
777 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
779 goto print_clause_size
;
781 case OMP_CLAUSE__CACHE_
:
783 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
785 goto print_clause_size
;
787 case OMP_CLAUSE_NUM_TEAMS
:
788 pp_string (pp
, "num_teams(");
789 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
794 case OMP_CLAUSE_THREAD_LIMIT
:
795 pp_string (pp
, "thread_limit(");
796 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
801 case OMP_CLAUSE_DEVICE
:
802 pp_string (pp
, "device(");
803 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
808 case OMP_CLAUSE_DIST_SCHEDULE
:
809 pp_string (pp
, "dist_schedule(static");
810 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
813 dump_generic_node (pp
,
814 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
820 case OMP_CLAUSE_PROC_BIND
:
821 pp_string (pp
, "proc_bind(");
822 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
824 case OMP_CLAUSE_PROC_BIND_MASTER
:
825 pp_string (pp
, "master");
827 case OMP_CLAUSE_PROC_BIND_CLOSE
:
828 pp_string (pp
, "close");
830 case OMP_CLAUSE_PROC_BIND_SPREAD
:
831 pp_string (pp
, "spread");
839 case OMP_CLAUSE_SAFELEN
:
840 pp_string (pp
, "safelen(");
841 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
846 case OMP_CLAUSE_SIMDLEN
:
847 pp_string (pp
, "simdlen(");
848 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
853 case OMP_CLAUSE_PRIORITY
:
854 pp_string (pp
, "priority(");
855 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
860 case OMP_CLAUSE_GRAINSIZE
:
861 pp_string (pp
, "grainsize(");
862 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
867 case OMP_CLAUSE_NUM_TASKS
:
868 pp_string (pp
, "num_tasks(");
869 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
874 case OMP_CLAUSE_HINT
:
875 pp_string (pp
, "hint(");
876 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
881 case OMP_CLAUSE_DEFAULTMAP
:
882 pp_string (pp
, "defaultmap(tofrom:scalar)");
885 case OMP_CLAUSE__SIMDUID_
:
886 pp_string (pp
, "_simduid_(");
887 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
892 case OMP_CLAUSE__SIMT_
:
893 pp_string (pp
, "_simt_");
896 case OMP_CLAUSE_GANG
:
897 pp_string (pp
, "gang");
898 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
900 pp_string (pp
, "(num: ");
901 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
904 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
906 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
910 pp_string (pp
, "static:");
911 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
912 == integer_minus_one_node
)
913 pp_character (pp
, '*');
915 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
918 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
919 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
923 case OMP_CLAUSE_ASYNC
:
924 pp_string (pp
, "async");
925 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
927 pp_character(pp
, '(');
928 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
930 pp_character(pp
, ')');
934 case OMP_CLAUSE_AUTO
:
936 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
939 case OMP_CLAUSE_WAIT
:
940 pp_string (pp
, "wait(");
941 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
943 pp_character(pp
, ')');
946 case OMP_CLAUSE_WORKER
:
947 pp_string (pp
, "worker");
948 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
951 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
957 case OMP_CLAUSE_VECTOR
:
958 pp_string (pp
, "vector");
959 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
962 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
968 case OMP_CLAUSE_NUM_GANGS
:
969 pp_string (pp
, "num_gangs(");
970 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
972 pp_character (pp
, ')');
975 case OMP_CLAUSE_NUM_WORKERS
:
976 pp_string (pp
, "num_workers(");
977 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
979 pp_character (pp
, ')');
982 case OMP_CLAUSE_VECTOR_LENGTH
:
983 pp_string (pp
, "vector_length(");
984 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
986 pp_character (pp
, ')');
989 case OMP_CLAUSE_INBRANCH
:
990 pp_string (pp
, "inbranch");
992 case OMP_CLAUSE_NOTINBRANCH
:
993 pp_string (pp
, "notinbranch");
996 pp_string (pp
, "for");
998 case OMP_CLAUSE_PARALLEL
:
999 pp_string (pp
, "parallel");
1001 case OMP_CLAUSE_SECTIONS
:
1002 pp_string (pp
, "sections");
1004 case OMP_CLAUSE_TASKGROUP
:
1005 pp_string (pp
, "taskgroup");
1007 case OMP_CLAUSE_NOGROUP
:
1008 pp_string (pp
, "nogroup");
1010 case OMP_CLAUSE_THREADS
:
1011 pp_string (pp
, "threads");
1013 case OMP_CLAUSE_SIMD
:
1014 pp_string (pp
, "simd");
1016 case OMP_CLAUSE_INDEPENDENT
:
1017 pp_string (pp
, "independent");
1019 case OMP_CLAUSE_TILE
:
1020 pp_string (pp
, "tile(");
1021 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1023 pp_right_paren (pp
);
1026 case OMP_CLAUSE__GRIDDIM_
:
1027 pp_string (pp
, "_griddim_(");
1028 pp_unsigned_wide_integer (pp
, OMP_CLAUSE__GRIDDIM__DIMENSION (clause
));
1030 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__SIZE (clause
), spc
, flags
,
1033 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__GROUP (clause
), spc
, flags
,
1035 pp_right_paren (pp
);
1039 /* Should never happen. */
1040 dump_generic_node (pp
, clause
, spc
, flags
, false);
1046 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1047 dump_generic_node. */
1050 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
1058 dump_omp_clause (pp
, clause
, spc
, flags
);
1059 clause
= OMP_CLAUSE_CHAIN (clause
);
1067 /* Dump location LOC to PP. */
1070 dump_location (pretty_printer
*pp
, location_t loc
)
1072 expanded_location xloc
= expand_location (loc
);
1074 pp_left_bracket (pp
);
1077 pp_string (pp
, xloc
.file
);
1078 pp_string (pp
, ":");
1080 pp_decimal_int (pp
, xloc
.line
);
1082 pp_decimal_int (pp
, xloc
.column
);
1083 pp_string (pp
, "] ");
1087 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1088 dump_generic_node. */
1091 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, dump_flags_t flags
)
1095 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1097 if (flags
& TDF_ADDRESS
)
1098 pp_printf (pp
, "[%p] ", (void *) block
);
1100 if (BLOCK_ABSTRACT (block
))
1101 pp_string (pp
, "[abstract] ");
1103 if (TREE_ASM_WRITTEN (block
))
1104 pp_string (pp
, "[written] ");
1106 if (flags
& TDF_SLIM
)
1109 if (BLOCK_SOURCE_LOCATION (block
))
1110 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1112 newline_and_indent (pp
, spc
+ 2);
1114 if (BLOCK_SUPERCONTEXT (block
))
1116 pp_string (pp
, "SUPERCONTEXT: ");
1117 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1118 flags
| TDF_SLIM
, false);
1119 newline_and_indent (pp
, spc
+ 2);
1122 if (BLOCK_SUBBLOCKS (block
))
1124 pp_string (pp
, "SUBBLOCKS: ");
1125 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1127 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1130 newline_and_indent (pp
, spc
+ 2);
1133 if (BLOCK_CHAIN (block
))
1135 pp_string (pp
, "SIBLINGS: ");
1136 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1138 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1141 newline_and_indent (pp
, spc
+ 2);
1144 if (BLOCK_VARS (block
))
1146 pp_string (pp
, "VARS: ");
1147 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1149 dump_generic_node (pp
, t
, 0, flags
, false);
1152 newline_and_indent (pp
, spc
+ 2);
1155 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1158 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1160 pp_string (pp
, "NONLOCALIZED_VARS: ");
1161 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1163 dump_generic_node (pp
, t
, 0, flags
, false);
1166 newline_and_indent (pp
, spc
+ 2);
1169 if (BLOCK_ABSTRACT_ORIGIN (block
))
1171 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1172 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1173 flags
| TDF_SLIM
, false);
1174 newline_and_indent (pp
, spc
+ 2);
1177 if (BLOCK_FRAGMENT_ORIGIN (block
))
1179 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1180 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1181 flags
| TDF_SLIM
, false);
1182 newline_and_indent (pp
, spc
+ 2);
1185 if (BLOCK_FRAGMENT_CHAIN (block
))
1187 pp_string (pp
, "FRAGMENT_CHAIN: ");
1188 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1190 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1193 newline_and_indent (pp
, spc
+ 2);
1198 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1199 indent. FLAGS specifies details to show in the dump (see TDF_* in
1200 dumpfile.h). If IS_STMT is true, the object printed is considered
1201 to be a statement and it is terminated by ';' if appropriate. */
1204 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
,
1211 enum tree_code code
;
1213 if (node
== NULL_TREE
)
1216 is_expr
= EXPR_P (node
);
1218 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1219 pp_printf (pp
, "<&%p> ", (void *)node
);
1221 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1222 dump_location (pp
, EXPR_LOCATION (node
));
1224 code
= TREE_CODE (node
);
1228 pp_string (pp
, "<<< error >>>");
1231 case IDENTIFIER_NODE
:
1232 pp_tree_identifier (pp
, node
);
1236 while (node
&& node
!= error_mark_node
)
1238 if (TREE_PURPOSE (node
))
1240 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1243 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1244 node
= TREE_CHAIN (node
);
1245 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1254 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1260 if (TREE_VEC_LENGTH (node
) > 0)
1262 size_t len
= TREE_VEC_LENGTH (node
);
1263 for (i
= 0; i
< len
- 1; i
++)
1265 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1270 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1277 case POINTER_BOUNDS_TYPE
:
1280 case FIXED_POINT_TYPE
:
1286 unsigned int quals
= TYPE_QUALS (node
);
1287 enum tree_code_class tclass
;
1289 if (quals
& TYPE_QUAL_ATOMIC
)
1290 pp_string (pp
, "atomic ");
1291 if (quals
& TYPE_QUAL_CONST
)
1292 pp_string (pp
, "const ");
1293 else if (quals
& TYPE_QUAL_VOLATILE
)
1294 pp_string (pp
, "volatile ");
1295 else if (quals
& TYPE_QUAL_RESTRICT
)
1296 pp_string (pp
, "restrict ");
1298 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1300 pp_string (pp
, "<address-space-");
1301 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1302 pp_string (pp
, "> ");
1305 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1307 if (tclass
== tcc_declaration
)
1309 if (DECL_NAME (node
))
1310 dump_decl_name (pp
, node
, flags
);
1312 pp_string (pp
, "<unnamed type decl>");
1314 else if (tclass
== tcc_type
)
1316 if (TYPE_NAME (node
))
1318 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1319 pp_tree_identifier (pp
, TYPE_NAME (node
));
1320 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1321 && DECL_NAME (TYPE_NAME (node
)))
1322 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1324 pp_string (pp
, "<unnamed type>");
1326 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1328 pp_string (pp
, "vector");
1330 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1331 pp_string (pp
, ") ");
1332 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1334 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1336 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1337 pp_string (pp
, (TYPE_UNSIGNED (node
)
1340 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1341 pp_string (pp
, (TYPE_UNSIGNED (node
)
1344 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1345 pp_string (pp
, (TYPE_UNSIGNED (node
)
1348 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1349 pp_string (pp
, (TYPE_UNSIGNED (node
)
1352 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1353 pp_string (pp
, (TYPE_UNSIGNED (node
)
1354 ? "unsigned long long"
1355 : "signed long long"));
1356 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1357 && pow2p_hwi (TYPE_PRECISION (node
)))
1359 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1360 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1361 pp_string (pp
, "_t");
1365 pp_string (pp
, (TYPE_UNSIGNED (node
)
1366 ? "<unnamed-unsigned:"
1367 : "<unnamed-signed:"));
1368 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1372 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1374 pp_string (pp
, "__complex__ ");
1375 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1377 else if (TREE_CODE (node
) == REAL_TYPE
)
1379 pp_string (pp
, "<float:");
1380 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1383 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1385 pp_string (pp
, "<fixed-point-");
1386 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1387 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1390 else if (TREE_CODE (node
) == VOID_TYPE
)
1391 pp_string (pp
, "void");
1393 pp_string (pp
, "<unnamed type>");
1399 case REFERENCE_TYPE
:
1400 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1402 if (TREE_TYPE (node
) == NULL
)
1404 pp_string (pp
, str
);
1405 pp_string (pp
, "<null type>");
1407 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1409 tree fnode
= TREE_TYPE (node
);
1411 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1414 pp_string (pp
, str
);
1415 if (TYPE_IDENTIFIER (node
))
1416 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1417 else if (flags
& TDF_NOUID
)
1418 pp_printf (pp
, "<Txxxx>");
1420 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1422 pp_right_paren (pp
);
1423 dump_function_declaration (pp
, fnode
, spc
, flags
);
1427 unsigned int quals
= TYPE_QUALS (node
);
1429 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1431 pp_string (pp
, str
);
1433 if (quals
& TYPE_QUAL_CONST
)
1434 pp_string (pp
, " const");
1435 if (quals
& TYPE_QUAL_VOLATILE
)
1436 pp_string (pp
, " volatile");
1437 if (quals
& TYPE_QUAL_RESTRICT
)
1438 pp_string (pp
, " restrict");
1440 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1442 pp_string (pp
, " <address-space-");
1443 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1447 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1448 pp_string (pp
, " {ref-all}");
1458 if (flags
& TDF_GIMPLE
)
1460 pp_string (pp
, "__MEM <");
1461 dump_generic_node (pp
, TREE_TYPE (node
),
1462 spc
, flags
| TDF_SLIM
, false);
1463 if (TYPE_ALIGN (TREE_TYPE (node
))
1464 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
1466 pp_string (pp
, ", ");
1467 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
1470 pp_string (pp
, " (");
1471 if (TREE_TYPE (TREE_OPERAND (node
, 0))
1472 != TREE_TYPE (TREE_OPERAND (node
, 1)))
1475 dump_generic_node (pp
, TREE_TYPE (TREE_OPERAND (node
, 1)),
1476 spc
, flags
| TDF_SLIM
, false);
1477 pp_right_paren (pp
);
1479 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1480 spc
, flags
| TDF_SLIM
, false);
1481 if (! integer_zerop (TREE_OPERAND (node
, 1)))
1483 pp_string (pp
, " + ");
1484 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1485 spc
, flags
| TDF_SLIM
, false);
1487 pp_right_paren (pp
);
1489 else if (integer_zerop (TREE_OPERAND (node
, 1))
1490 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1491 infer them and MEM_ATTR caching will share MEM_REFs
1492 with differently-typed op0s. */
1493 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1494 /* Released SSA_NAMES have no TREE_TYPE. */
1495 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1496 /* Same pointer types, but ignoring POINTER_TYPE vs.
1498 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1499 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1500 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1501 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1502 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1503 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1504 /* Same value types ignoring qualifiers. */
1505 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1506 == TYPE_MAIN_VARIANT
1507 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1508 && (!(flags
& TDF_ALIAS
)
1509 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1511 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1514 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1518 dump_generic_node (pp
,
1519 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1526 pp_string (pp
, "MEM[");
1528 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1529 dump_generic_node (pp
, ptype
,
1530 spc
, flags
| TDF_SLIM
, false);
1531 pp_right_paren (pp
);
1532 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1534 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1536 pp_string (pp
, " + ");
1537 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1540 if ((flags
& TDF_ALIAS
)
1541 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1543 pp_string (pp
, " clique ");
1544 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1545 pp_string (pp
, " base ");
1546 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1548 pp_right_bracket (pp
);
1553 case TARGET_MEM_REF
:
1555 const char *sep
= "";
1558 pp_string (pp
, "MEM[");
1560 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1562 pp_string (pp
, sep
);
1564 pp_string (pp
, "symbol: ");
1565 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1570 pp_string (pp
, sep
);
1572 pp_string (pp
, "base: ");
1573 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1575 tmp
= TMR_INDEX2 (node
);
1578 pp_string (pp
, sep
);
1580 pp_string (pp
, "base: ");
1581 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1583 tmp
= TMR_INDEX (node
);
1586 pp_string (pp
, sep
);
1588 pp_string (pp
, "index: ");
1589 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1591 tmp
= TMR_STEP (node
);
1594 pp_string (pp
, sep
);
1596 pp_string (pp
, "step: ");
1597 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1599 tmp
= TMR_OFFSET (node
);
1602 pp_string (pp
, sep
);
1604 pp_string (pp
, "offset: ");
1605 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1607 pp_right_bracket (pp
);
1615 /* Print the innermost component type. */
1616 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1617 tmp
= TREE_TYPE (tmp
))
1619 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1621 /* Print the dimensions. */
1622 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1623 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1629 case QUAL_UNION_TYPE
:
1631 unsigned int quals
= TYPE_QUALS (node
);
1633 if (quals
& TYPE_QUAL_ATOMIC
)
1634 pp_string (pp
, "atomic ");
1635 if (quals
& TYPE_QUAL_CONST
)
1636 pp_string (pp
, "const ");
1637 if (quals
& TYPE_QUAL_VOLATILE
)
1638 pp_string (pp
, "volatile ");
1640 /* Print the name of the structure. */
1641 if (TREE_CODE (node
) == RECORD_TYPE
)
1642 pp_string (pp
, "struct ");
1643 else if (TREE_CODE (node
) == UNION_TYPE
)
1644 pp_string (pp
, "union ");
1646 if (TYPE_NAME (node
))
1647 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1648 else if (!(flags
& TDF_SLIM
))
1649 /* FIXME: If we eliminate the 'else' above and attempt
1650 to show the fields for named types, we may get stuck
1651 following a cycle of pointers to structs. The alleged
1652 self-reference check in print_struct_decl will not detect
1653 cycles involving more than one pointer or struct type. */
1654 print_struct_decl (pp
, node
, spc
, flags
);
1663 if (flags
& TDF_GIMPLE
1664 && (POINTER_TYPE_P (TREE_TYPE (node
))
1665 || (TYPE_PRECISION (TREE_TYPE (node
))
1666 < TYPE_PRECISION (integer_type_node
))
1667 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1669 pp_string (pp
, "_Literal (");
1670 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1671 pp_string (pp
, ") ");
1673 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
1674 && ! (flags
& TDF_GIMPLE
))
1676 /* In the case of a pointer, one may want to divide by the
1677 size of the pointed-to type. Unfortunately, this not
1678 straightforward. The C front-end maps expressions
1683 in such a way that the two INTEGER_CST nodes for "5" have
1684 different values but identical types. In the latter
1685 case, the 5 is multiplied by sizeof (int) in c-common.c
1686 (pointer_int_sum) to convert it to a byte address, and
1687 yet the type of the node is left unchanged. Argh. What
1688 is consistent though is that the number value corresponds
1689 to bytes (UNITS) offset.
1691 NB: Neither of the following divisors can be trivially
1692 used to recover the original literal:
1694 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1695 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1696 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1697 pp_string (pp
, "B"); /* pseudo-unit */
1699 else if (tree_fits_shwi_p (node
))
1700 pp_wide_integer (pp
, tree_to_shwi (node
));
1701 else if (tree_fits_uhwi_p (node
))
1702 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1705 wide_int val
= wi::to_wide (node
);
1707 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1712 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
1713 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
1715 if ((flags
& TDF_GIMPLE
)
1716 && ! (POINTER_TYPE_P (TREE_TYPE (node
))
1717 || (TYPE_PRECISION (TREE_TYPE (node
))
1718 < TYPE_PRECISION (integer_type_node
))
1719 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1721 if (TYPE_UNSIGNED (TREE_TYPE (node
)))
1722 pp_character (pp
, 'u');
1723 if (TYPE_PRECISION (TREE_TYPE (node
))
1724 == TYPE_PRECISION (unsigned_type_node
))
1726 else if (TYPE_PRECISION (TREE_TYPE (node
))
1727 == TYPE_PRECISION (long_unsigned_type_node
))
1728 pp_character (pp
, 'l');
1729 else if (TYPE_PRECISION (TREE_TYPE (node
))
1730 == TYPE_PRECISION (long_long_unsigned_type_node
))
1731 pp_string (pp
, "ll");
1733 if (TREE_OVERFLOW (node
))
1734 pp_string (pp
, "(OVF)");
1738 pp_string (pp
, "POLY_INT_CST [");
1739 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, 0), spc
, flags
, false);
1740 for (unsigned int i
= 1; i
< NUM_POLY_INT_COEFFS
; ++i
)
1742 pp_string (pp
, ", ");
1743 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, i
),
1746 pp_string (pp
, "]");
1750 /* Code copied from print_node. */
1753 if (TREE_OVERFLOW (node
))
1754 pp_string (pp
, " overflow");
1756 d
= TREE_REAL_CST (node
);
1757 if (REAL_VALUE_ISINF (d
))
1758 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1759 else if (REAL_VALUE_ISNAN (d
))
1760 pp_string (pp
, " Nan");
1764 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1765 pp_string (pp
, string
);
1773 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1774 pp_string (pp
, string
);
1779 pp_string (pp
, "__complex__ (");
1780 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
1781 pp_string (pp
, ", ");
1782 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
1783 pp_right_paren (pp
);
1787 pp_string (pp
, "\"");
1788 pretty_print_string (pp
, TREE_STRING_POINTER (node
));
1789 pp_string (pp
, "\"");
1795 pp_string (pp
, "{ ");
1796 unsigned HOST_WIDE_INT nunits
;
1797 if (!VECTOR_CST_NELTS (node
).is_constant (&nunits
))
1798 nunits
= vector_cst_encoded_nelts (node
);
1799 for (i
= 0; i
< nunits
; ++i
)
1802 pp_string (pp
, ", ");
1803 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
1806 if (!VECTOR_CST_NELTS (node
).is_constant ())
1807 pp_string (pp
, ", ...");
1808 pp_string (pp
, " }");
1814 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1816 if (TREE_CODE (node
) == METHOD_TYPE
)
1818 if (TYPE_METHOD_BASETYPE (node
))
1819 dump_generic_node (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1822 pp_string (pp
, "<null method basetype>");
1823 pp_colon_colon (pp
);
1825 if (TYPE_IDENTIFIER (node
))
1826 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1827 else if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1828 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1829 else if (flags
& TDF_NOUID
)
1830 pp_printf (pp
, "<Txxxx>");
1832 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1833 dump_function_declaration (pp
, node
, spc
, flags
);
1838 dump_decl_name (pp
, node
, flags
);
1842 if (DECL_NAME (node
))
1843 dump_decl_name (pp
, node
, flags
);
1844 else if (LABEL_DECL_UID (node
) != -1)
1846 if (flags
& TDF_GIMPLE
)
1847 pp_printf (pp
, "L%d", (int) LABEL_DECL_UID (node
));
1849 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
1853 if (flags
& TDF_NOUID
)
1854 pp_string (pp
, "<D.xxxx>");
1857 if (flags
& TDF_GIMPLE
)
1858 pp_printf (pp
, "<D%u>", DECL_UID (node
));
1860 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
1866 if (DECL_IS_BUILTIN (node
))
1868 /* Don't print the declaration of built-in types. */
1871 if (DECL_NAME (node
))
1872 dump_decl_name (pp
, node
, flags
);
1873 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1875 pp_string (pp
, (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1876 ? "union" : "struct "));
1877 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1880 pp_string (pp
, "<anon>");
1886 case DEBUG_EXPR_DECL
:
1887 case NAMESPACE_DECL
:
1889 dump_decl_name (pp
, node
, flags
);
1893 pp_string (pp
, "<retval>");
1897 op0
= TREE_OPERAND (node
, 0);
1900 && (TREE_CODE (op0
) == INDIRECT_REF
1901 || (TREE_CODE (op0
) == MEM_REF
1902 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1903 && integer_zerop (TREE_OPERAND (op0
, 1))
1904 /* Dump the types of INTEGER_CSTs explicitly, for we
1905 can't infer them and MEM_ATTR caching will share
1906 MEM_REFs with differently-typed op0s. */
1907 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1908 /* Released SSA_NAMES have no TREE_TYPE. */
1909 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1910 /* Same pointer types, but ignoring POINTER_TYPE vs.
1912 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1913 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1914 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1915 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1916 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1917 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1918 /* Same value types ignoring qualifiers. */
1919 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1920 == TYPE_MAIN_VARIANT
1921 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
1922 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
1924 op0
= TREE_OPERAND (op0
, 0);
1927 if (op_prio (op0
) < op_prio (node
))
1929 dump_generic_node (pp
, op0
, spc
, flags
, false);
1930 if (op_prio (op0
) < op_prio (node
))
1931 pp_right_paren (pp
);
1932 pp_string (pp
, str
);
1933 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1934 op0
= component_ref_field_offset (node
);
1935 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1937 pp_string (pp
, "{off: ");
1938 dump_generic_node (pp
, op0
, spc
, flags
, false);
1939 pp_right_brace (pp
);
1944 pp_string (pp
, "BIT_FIELD_REF <");
1945 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1946 pp_string (pp
, ", ");
1947 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1948 pp_string (pp
, ", ");
1949 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1953 case BIT_INSERT_EXPR
:
1954 pp_string (pp
, "BIT_INSERT_EXPR <");
1955 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1956 pp_string (pp
, ", ");
1957 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1958 pp_string (pp
, ", ");
1959 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1960 pp_string (pp
, " (");
1961 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
1963 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
1965 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
1967 pp_string (pp
, " bits)>");
1971 case ARRAY_RANGE_REF
:
1972 op0
= TREE_OPERAND (node
, 0);
1973 if (op_prio (op0
) < op_prio (node
))
1975 dump_generic_node (pp
, op0
, spc
, flags
, false);
1976 if (op_prio (op0
) < op_prio (node
))
1977 pp_right_paren (pp
);
1978 pp_left_bracket (pp
);
1979 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1980 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1981 pp_string (pp
, " ...");
1982 pp_right_bracket (pp
);
1984 op0
= array_ref_low_bound (node
);
1985 op1
= array_ref_element_size (node
);
1987 if (!integer_zerop (op0
)
1988 || TREE_OPERAND (node
, 2)
1989 || TREE_OPERAND (node
, 3))
1991 pp_string (pp
, "{lb: ");
1992 dump_generic_node (pp
, op0
, spc
, flags
, false);
1993 pp_string (pp
, " sz: ");
1994 dump_generic_node (pp
, op1
, spc
, flags
, false);
1995 pp_right_brace (pp
);
2001 unsigned HOST_WIDE_INT ix
;
2003 bool is_struct_init
= false;
2004 bool is_array_init
= false;
2007 if (TREE_CLOBBER_P (node
))
2008 pp_string (pp
, "CLOBBER");
2009 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
2010 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
2011 is_struct_init
= true;
2012 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
2013 && TYPE_DOMAIN (TREE_TYPE (node
))
2014 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
2015 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
2018 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
2019 is_array_init
= true;
2020 curidx
= wi::to_widest (minv
);
2022 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
2029 dump_generic_node (pp
, field
, spc
, flags
, false);
2032 else if (is_array_init
2033 && (TREE_CODE (field
) != INTEGER_CST
2034 || curidx
!= wi::to_widest (field
)))
2036 pp_left_bracket (pp
);
2037 if (TREE_CODE (field
) == RANGE_EXPR
)
2039 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
2041 pp_string (pp
, " ... ");
2042 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
2044 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
2045 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
2048 dump_generic_node (pp
, field
, spc
, flags
, false);
2049 if (TREE_CODE (field
) == INTEGER_CST
)
2050 curidx
= wi::to_widest (field
);
2051 pp_string (pp
, "]=");
2056 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
2057 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
2058 val
= TREE_OPERAND (val
, 0);
2059 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
2060 dump_decl_name (pp
, val
, flags
);
2062 dump_generic_node (pp
, val
, spc
, flags
, false);
2063 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2069 pp_right_brace (pp
);
2076 if (flags
& TDF_SLIM
)
2078 pp_string (pp
, "<COMPOUND_EXPR>");
2082 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2083 spc
, flags
, !(flags
& TDF_SLIM
));
2084 if (flags
& TDF_SLIM
)
2085 newline_and_indent (pp
, spc
);
2092 for (tp
= &TREE_OPERAND (node
, 1);
2093 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2094 tp
= &TREE_OPERAND (*tp
, 1))
2096 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2097 spc
, flags
, !(flags
& TDF_SLIM
));
2098 if (flags
& TDF_SLIM
)
2099 newline_and_indent (pp
, spc
);
2107 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2111 case STATEMENT_LIST
:
2113 tree_stmt_iterator si
;
2116 if (flags
& TDF_SLIM
)
2118 pp_string (pp
, "<STATEMENT_LIST>");
2122 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2125 newline_and_indent (pp
, spc
);
2128 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2135 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2140 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2145 pp_string (pp
, "TARGET_EXPR <");
2146 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2149 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2154 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2159 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2161 pp_string (pp
, "if (");
2162 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2163 pp_right_paren (pp
);
2164 /* The lowered cond_exprs should always be printed in full. */
2165 if (COND_EXPR_THEN (node
)
2166 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2167 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2168 && COND_EXPR_ELSE (node
)
2169 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2170 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2173 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2175 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2177 pp_string (pp
, " else ");
2178 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2182 else if (!(flags
& TDF_SLIM
))
2184 /* Output COND_EXPR_THEN. */
2185 if (COND_EXPR_THEN (node
))
2187 newline_and_indent (pp
, spc
+2);
2189 newline_and_indent (pp
, spc
+4);
2190 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2192 newline_and_indent (pp
, spc
+2);
2193 pp_right_brace (pp
);
2196 /* Output COND_EXPR_ELSE. */
2197 if (COND_EXPR_ELSE (node
)
2198 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2200 newline_and_indent (pp
, spc
);
2201 pp_string (pp
, "else");
2202 newline_and_indent (pp
, spc
+2);
2204 newline_and_indent (pp
, spc
+4);
2205 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2207 newline_and_indent (pp
, spc
+2);
2208 pp_right_brace (pp
);
2215 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2219 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2223 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2229 if (!(flags
& TDF_SLIM
))
2231 if (BIND_EXPR_VARS (node
))
2235 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2237 print_declaration (pp
, op0
, spc
+2, flags
);
2242 newline_and_indent (pp
, spc
+2);
2243 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2244 newline_and_indent (pp
, spc
);
2245 pp_right_brace (pp
);
2251 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2252 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2254 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2256 /* Print parameters. */
2261 call_expr_arg_iterator iter
;
2262 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2264 dump_generic_node (pp
, arg
, spc
, flags
, false);
2265 if (more_call_expr_args_p (&iter
))
2272 if (CALL_EXPR_VA_ARG_PACK (node
))
2274 if (call_expr_nargs (node
) > 0)
2279 pp_string (pp
, "__builtin_va_arg_pack ()");
2281 pp_right_paren (pp
);
2283 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2286 pp_string (pp
, " [static-chain: ");
2287 dump_generic_node (pp
, op1
, spc
, flags
, false);
2288 pp_right_bracket (pp
);
2291 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2292 pp_string (pp
, " [return slot optimization]");
2293 if (CALL_EXPR_TAILCALL (node
))
2294 pp_string (pp
, " [tail call]");
2297 case WITH_CLEANUP_EXPR
:
2301 case CLEANUP_POINT_EXPR
:
2302 pp_string (pp
, "<<cleanup_point ");
2303 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2304 pp_string (pp
, ">>");
2307 case PLACEHOLDER_EXPR
:
2308 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2309 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2313 /* Binary arithmetic and logic expressions. */
2314 case WIDEN_SUM_EXPR
:
2315 case WIDEN_MULT_EXPR
:
2317 case MULT_HIGHPART_EXPR
:
2319 case POINTER_PLUS_EXPR
:
2320 case POINTER_DIFF_EXPR
:
2322 case TRUNC_DIV_EXPR
:
2324 case FLOOR_DIV_EXPR
:
2325 case ROUND_DIV_EXPR
:
2326 case TRUNC_MOD_EXPR
:
2328 case FLOOR_MOD_EXPR
:
2329 case ROUND_MOD_EXPR
:
2331 case EXACT_DIV_EXPR
:
2336 case WIDEN_LSHIFT_EXPR
:
2340 case TRUTH_ANDIF_EXPR
:
2341 case TRUTH_ORIF_EXPR
:
2342 case TRUTH_AND_EXPR
:
2344 case TRUTH_XOR_EXPR
:
2358 case UNORDERED_EXPR
:
2360 const char *op
= op_symbol (node
);
2361 op0
= TREE_OPERAND (node
, 0);
2362 op1
= TREE_OPERAND (node
, 1);
2364 /* When the operands are expressions with less priority,
2365 keep semantics of the tree representation. */
2366 if (op_prio (op0
) <= op_prio (node
))
2369 dump_generic_node (pp
, op0
, spc
, flags
, false);
2370 pp_right_paren (pp
);
2373 dump_generic_node (pp
, op0
, spc
, flags
, false);
2379 /* When the operands are expressions with less priority,
2380 keep semantics of the tree representation. */
2381 if (op_prio (op1
) <= op_prio (node
))
2384 dump_generic_node (pp
, op1
, spc
, flags
, false);
2385 pp_right_paren (pp
);
2388 dump_generic_node (pp
, op1
, spc
, flags
, false);
2392 /* Unary arithmetic and logic expressions. */
2395 case TRUTH_NOT_EXPR
:
2397 case PREDECREMENT_EXPR
:
2398 case PREINCREMENT_EXPR
:
2400 if (TREE_CODE (node
) == ADDR_EXPR
2401 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2402 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2403 ; /* Do not output '&' for strings and function pointers. */
2405 pp_string (pp
, op_symbol (node
));
2407 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2410 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2411 pp_right_paren (pp
);
2414 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2417 case POSTDECREMENT_EXPR
:
2418 case POSTINCREMENT_EXPR
:
2419 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2422 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2423 pp_right_paren (pp
);
2426 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2427 pp_string (pp
, op_symbol (node
));
2431 pp_string (pp
, "MIN_EXPR <");
2432 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2433 pp_string (pp
, ", ");
2434 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2439 pp_string (pp
, "MAX_EXPR <");
2440 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2441 pp_string (pp
, ", ");
2442 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2447 pp_string (pp
, "ABS_EXPR <");
2448 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2456 case ADDR_SPACE_CONVERT_EXPR
:
2457 case FIXED_CONVERT_EXPR
:
2458 case FIX_TRUNC_EXPR
:
2461 type
= TREE_TYPE (node
);
2462 op0
= TREE_OPERAND (node
, 0);
2463 if (type
!= TREE_TYPE (op0
))
2466 dump_generic_node (pp
, type
, spc
, flags
, false);
2467 pp_string (pp
, ") ");
2469 if (op_prio (op0
) < op_prio (node
))
2471 dump_generic_node (pp
, op0
, spc
, flags
, false);
2472 if (op_prio (op0
) < op_prio (node
))
2473 pp_right_paren (pp
);
2476 case VIEW_CONVERT_EXPR
:
2477 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2478 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2479 pp_string (pp
, ">(");
2480 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2481 pp_right_paren (pp
);
2485 pp_string (pp
, "((");
2486 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2487 pp_string (pp
, "))");
2490 case NON_LVALUE_EXPR
:
2491 pp_string (pp
, "NON_LVALUE_EXPR <");
2492 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2497 pp_string (pp
, "SAVE_EXPR <");
2498 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2503 pp_string (pp
, "COMPLEX_EXPR <");
2504 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2505 pp_string (pp
, ", ");
2506 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2511 pp_string (pp
, "CONJ_EXPR <");
2512 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2517 if (flags
& TDF_GIMPLE
)
2519 pp_string (pp
, "__real ");
2520 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2524 pp_string (pp
, "REALPART_EXPR <");
2525 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2531 if (flags
& TDF_GIMPLE
)
2533 pp_string (pp
, "__imag ");
2534 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2538 pp_string (pp
, "IMAGPART_EXPR <");
2539 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2545 pp_string (pp
, "VA_ARG_EXPR <");
2546 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2550 case TRY_FINALLY_EXPR
:
2551 case TRY_CATCH_EXPR
:
2552 pp_string (pp
, "try");
2553 newline_and_indent (pp
, spc
+2);
2555 newline_and_indent (pp
, spc
+4);
2556 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2557 newline_and_indent (pp
, spc
+2);
2558 pp_right_brace (pp
);
2559 newline_and_indent (pp
, spc
);
2561 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2562 newline_and_indent (pp
, spc
+2);
2564 newline_and_indent (pp
, spc
+4);
2565 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2566 newline_and_indent (pp
, spc
+2);
2567 pp_right_brace (pp
);
2572 pp_string (pp
, "catch (");
2573 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2574 pp_right_paren (pp
);
2575 newline_and_indent (pp
, spc
+2);
2577 newline_and_indent (pp
, spc
+4);
2578 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2579 newline_and_indent (pp
, spc
+2);
2580 pp_right_brace (pp
);
2584 case EH_FILTER_EXPR
:
2585 pp_string (pp
, "<<<eh_filter (");
2586 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2587 pp_string (pp
, ")>>>");
2588 newline_and_indent (pp
, spc
+2);
2590 newline_and_indent (pp
, spc
+4);
2591 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2592 newline_and_indent (pp
, spc
+2);
2593 pp_right_brace (pp
);
2598 op0
= TREE_OPERAND (node
, 0);
2599 /* If this is for break or continue, don't bother printing it. */
2600 if (DECL_NAME (op0
))
2602 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2603 if (strcmp (name
, "break") == 0
2604 || strcmp (name
, "continue") == 0)
2607 dump_generic_node (pp
, op0
, spc
, flags
, false);
2609 if (DECL_NONLOCAL (op0
))
2610 pp_string (pp
, " [non-local]");
2614 pp_string (pp
, "while (1)");
2615 if (!(flags
& TDF_SLIM
))
2617 newline_and_indent (pp
, spc
+2);
2619 newline_and_indent (pp
, spc
+4);
2620 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2621 newline_and_indent (pp
, spc
+2);
2622 pp_right_brace (pp
);
2628 pp_string (pp
, "// predicted ");
2629 if (PREDICT_EXPR_OUTCOME (node
))
2630 pp_string (pp
, "likely by ");
2632 pp_string (pp
, "unlikely by ");
2633 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2634 pp_string (pp
, " predictor.");
2638 pp_string (pp
, "ANNOTATE_EXPR <");
2639 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2640 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2642 case annot_expr_ivdep_kind
:
2643 pp_string (pp
, ", ivdep");
2645 case annot_expr_unroll_kind
:
2646 pp_printf (pp
, ", unroll %d",
2647 (int) TREE_INT_CST_LOW (TREE_OPERAND (node
, 2)));
2649 case annot_expr_no_vector_kind
:
2650 pp_string (pp
, ", no-vector");
2652 case annot_expr_vector_kind
:
2653 pp_string (pp
, ", vector");
2655 case annot_expr_parallel_kind
:
2656 pp_string (pp
, ", parallel");
2665 pp_string (pp
, "return");
2666 op0
= TREE_OPERAND (node
, 0);
2670 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2671 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2674 dump_generic_node (pp
, op0
, spc
, flags
, false);
2679 pp_string (pp
, "if (");
2680 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2681 pp_string (pp
, ") break");
2685 pp_string (pp
, "switch (");
2686 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2687 pp_right_paren (pp
);
2688 if (!(flags
& TDF_SLIM
))
2690 newline_and_indent (pp
, spc
+2);
2692 if (SWITCH_BODY (node
))
2694 newline_and_indent (pp
, spc
+4);
2695 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2698 newline_and_indent (pp
, spc
+2);
2699 pp_right_brace (pp
);
2705 op0
= GOTO_DESTINATION (node
);
2706 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2708 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2709 if (strcmp (name
, "break") == 0
2710 || strcmp (name
, "continue") == 0)
2712 pp_string (pp
, name
);
2716 pp_string (pp
, "goto ");
2717 dump_generic_node (pp
, op0
, spc
, flags
, false);
2721 pp_string (pp
, "__asm__");
2722 if (ASM_VOLATILE_P (node
))
2723 pp_string (pp
, " __volatile__");
2725 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2727 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2729 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2730 if (ASM_CLOBBERS (node
))
2733 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2735 pp_right_paren (pp
);
2738 case CASE_LABEL_EXPR
:
2739 if (CASE_LOW (node
) && CASE_HIGH (node
))
2741 pp_string (pp
, "case ");
2742 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2743 pp_string (pp
, " ... ");
2744 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2746 else if (CASE_LOW (node
))
2748 pp_string (pp
, "case ");
2749 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2752 pp_string (pp
, "default");
2757 pp_string (pp
, "OBJ_TYPE_REF(");
2758 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2760 /* We omit the class type for -fcompare-debug because we may
2761 drop TYPE_BINFO early depending on debug info, and then
2762 virtual_method_call_p would return false, whereas when
2763 TYPE_BINFO is preserved it may still return true and then
2764 we'd print the class type. Compare tree and rtl dumps for
2765 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
2766 for example, at occurrences of OBJ_TYPE_REF. */
2767 if (!(flags
& (TDF_SLIM
| TDF_COMPARE_DEBUG
))
2768 && virtual_method_call_p (node
))
2770 pp_string (pp
, "(");
2771 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2772 pp_string (pp
, ")");
2774 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2776 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2777 pp_right_paren (pp
);
2781 if (SSA_NAME_IDENTIFIER (node
))
2783 if ((flags
& TDF_NOUID
)
2784 && SSA_NAME_VAR (node
)
2785 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
2786 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
2787 else if (! (flags
& TDF_GIMPLE
)
2788 || SSA_NAME_VAR (node
))
2789 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2793 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2794 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2795 pp_string (pp
, "(D)");
2796 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2797 pp_string (pp
, "(ab)");
2800 case WITH_SIZE_EXPR
:
2801 pp_string (pp
, "WITH_SIZE_EXPR <");
2802 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2803 pp_string (pp
, ", ");
2804 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2809 pp_string (pp
, "ASSERT_EXPR <");
2810 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2811 pp_string (pp
, ", ");
2812 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2817 pp_string (pp
, "scev_known");
2820 case SCEV_NOT_KNOWN
:
2821 pp_string (pp
, "scev_not_known");
2824 case POLYNOMIAL_CHREC
:
2826 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2827 pp_string (pp
, ", +, ");
2828 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2829 pp_printf (pp
, "}_%u", CHREC_VARIABLE (node
));
2833 case REALIGN_LOAD_EXPR
:
2834 pp_string (pp
, "REALIGN_LOAD <");
2835 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2836 pp_string (pp
, ", ");
2837 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2838 pp_string (pp
, ", ");
2839 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2844 pp_string (pp
, " VEC_COND_EXPR < ");
2845 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2846 pp_string (pp
, " , ");
2847 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2848 pp_string (pp
, " , ");
2849 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2850 pp_string (pp
, " > ");
2854 pp_string (pp
, " VEC_PERM_EXPR < ");
2855 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2856 pp_string (pp
, " , ");
2857 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2858 pp_string (pp
, " , ");
2859 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2860 pp_string (pp
, " > ");
2864 pp_string (pp
, " DOT_PROD_EXPR < ");
2865 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2866 pp_string (pp
, ", ");
2867 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2868 pp_string (pp
, ", ");
2869 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2870 pp_string (pp
, " > ");
2873 case WIDEN_MULT_PLUS_EXPR
:
2874 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
2875 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2876 pp_string (pp
, ", ");
2877 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2878 pp_string (pp
, ", ");
2879 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2880 pp_string (pp
, " > ");
2883 case WIDEN_MULT_MINUS_EXPR
:
2884 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
2885 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2886 pp_string (pp
, ", ");
2887 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2888 pp_string (pp
, ", ");
2889 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2890 pp_string (pp
, " > ");
2894 pp_string (pp
, " FMA_EXPR < ");
2895 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2896 pp_string (pp
, ", ");
2897 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2898 pp_string (pp
, ", ");
2899 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2900 pp_string (pp
, " > ");
2904 pp_string (pp
, "#pragma acc parallel");
2905 goto dump_omp_clauses_body
;
2908 pp_string (pp
, "#pragma acc kernels");
2909 goto dump_omp_clauses_body
;
2912 pp_string (pp
, "#pragma acc data");
2913 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2916 case OACC_HOST_DATA
:
2917 pp_string (pp
, "#pragma acc host_data");
2918 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2922 pp_string (pp
, "#pragma acc declare");
2923 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2927 pp_string (pp
, "#pragma acc update");
2928 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2931 case OACC_ENTER_DATA
:
2932 pp_string (pp
, "#pragma acc enter data");
2933 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2936 case OACC_EXIT_DATA
:
2937 pp_string (pp
, "#pragma acc exit data");
2938 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2942 pp_string (pp
, "#pragma acc cache");
2943 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2947 pp_string (pp
, "#pragma omp parallel");
2948 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2951 dump_omp_clauses_body
:
2952 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2956 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2958 newline_and_indent (pp
, spc
+ 2);
2960 newline_and_indent (pp
, spc
+ 4);
2961 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2962 newline_and_indent (pp
, spc
+ 2);
2963 pp_right_brace (pp
);
2969 pp_string (pp
, "#pragma omp task");
2970 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2974 pp_string (pp
, "#pragma omp for");
2978 pp_string (pp
, "#pragma omp simd");
2981 case OMP_DISTRIBUTE
:
2982 pp_string (pp
, "#pragma omp distribute");
2986 pp_string (pp
, "#pragma omp taskloop");
2990 pp_string (pp
, "#pragma acc loop");
2994 pp_string (pp
, "#pragma omp teams");
2995 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
2998 case OMP_TARGET_DATA
:
2999 pp_string (pp
, "#pragma omp target data");
3000 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
3003 case OMP_TARGET_ENTER_DATA
:
3004 pp_string (pp
, "#pragma omp target enter data");
3005 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3009 case OMP_TARGET_EXIT_DATA
:
3010 pp_string (pp
, "#pragma omp target exit data");
3011 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3016 pp_string (pp
, "#pragma omp target");
3017 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3020 case OMP_TARGET_UPDATE
:
3021 pp_string (pp
, "#pragma omp target update");
3022 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3027 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3028 if (!(flags
& TDF_SLIM
))
3032 if (OMP_FOR_PRE_BODY (node
))
3034 newline_and_indent (pp
, spc
+ 2);
3037 newline_and_indent (pp
, spc
);
3038 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3041 if (OMP_FOR_INIT (node
))
3044 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3047 newline_and_indent (pp
, spc
);
3048 pp_string (pp
, "for (");
3049 dump_generic_node (pp
,
3050 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
3052 pp_string (pp
, "; ");
3053 dump_generic_node (pp
,
3054 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
3056 pp_string (pp
, "; ");
3057 dump_generic_node (pp
,
3058 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3060 pp_right_paren (pp
);
3063 if (OMP_FOR_BODY (node
))
3065 newline_and_indent (pp
, spc
+ 2);
3067 newline_and_indent (pp
, spc
+ 4);
3068 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3070 newline_and_indent (pp
, spc
+ 2);
3071 pp_right_brace (pp
);
3073 if (OMP_FOR_INIT (node
))
3074 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3075 if (OMP_FOR_PRE_BODY (node
))
3078 newline_and_indent (pp
, spc
+ 2);
3079 pp_right_brace (pp
);
3086 pp_string (pp
, "#pragma omp sections");
3087 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3091 pp_string (pp
, "#pragma omp section");
3095 pp_string (pp
, "#pragma omp master");
3099 pp_string (pp
, "#pragma omp taskgroup");
3103 pp_string (pp
, "#pragma omp ordered");
3104 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3108 pp_string (pp
, "#pragma omp critical");
3109 if (OMP_CRITICAL_NAME (node
))
3113 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3115 pp_right_paren (pp
);
3117 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3121 pp_string (pp
, "#pragma omp atomic");
3122 if (OMP_ATOMIC_SEQ_CST (node
))
3123 pp_string (pp
, " seq_cst");
3124 newline_and_indent (pp
, spc
+ 2);
3125 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3129 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3132 case OMP_ATOMIC_READ
:
3133 pp_string (pp
, "#pragma omp atomic read");
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 case OMP_ATOMIC_CAPTURE_OLD
:
3142 case OMP_ATOMIC_CAPTURE_NEW
:
3143 pp_string (pp
, "#pragma omp atomic capture");
3144 if (OMP_ATOMIC_SEQ_CST (node
))
3145 pp_string (pp
, " seq_cst");
3146 newline_and_indent (pp
, spc
+ 2);
3147 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3151 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3155 pp_string (pp
, "#pragma omp single");
3156 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3160 dump_omp_clause (pp
, node
, spc
, flags
);
3164 case TRANSACTION_EXPR
:
3165 if (TRANSACTION_EXPR_OUTER (node
))
3166 pp_string (pp
, "__transaction_atomic [[outer]]");
3167 else if (TRANSACTION_EXPR_RELAXED (node
))
3168 pp_string (pp
, "__transaction_relaxed");
3170 pp_string (pp
, "__transaction_atomic");
3171 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3173 newline_and_indent (pp
, spc
);
3175 newline_and_indent (pp
, spc
+ 2);
3176 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3177 spc
+ 2, flags
, false);
3178 newline_and_indent (pp
, spc
);
3179 pp_right_brace (pp
);
3184 case VEC_SERIES_EXPR
:
3185 case VEC_WIDEN_MULT_HI_EXPR
:
3186 case VEC_WIDEN_MULT_LO_EXPR
:
3187 case VEC_WIDEN_MULT_EVEN_EXPR
:
3188 case VEC_WIDEN_MULT_ODD_EXPR
:
3189 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3190 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3192 for (str
= get_tree_code_name (code
); *str
; str
++)
3193 pp_character (pp
, TOUPPER (*str
));
3194 pp_string (pp
, " < ");
3195 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3196 pp_string (pp
, ", ");
3197 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3198 pp_string (pp
, " > ");
3201 case VEC_DUPLICATE_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
, " > ");
3210 case VEC_UNPACK_HI_EXPR
:
3211 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3212 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3213 pp_string (pp
, " > ");
3216 case VEC_UNPACK_LO_EXPR
:
3217 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3218 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3219 pp_string (pp
, " > ");
3222 case VEC_UNPACK_FLOAT_HI_EXPR
:
3223 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3224 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3225 pp_string (pp
, " > ");
3228 case VEC_UNPACK_FLOAT_LO_EXPR
:
3229 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3230 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3231 pp_string (pp
, " > ");
3234 case VEC_PACK_TRUNC_EXPR
:
3235 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3236 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3237 pp_string (pp
, ", ");
3238 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3239 pp_string (pp
, " > ");
3242 case VEC_PACK_SAT_EXPR
:
3243 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3244 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3245 pp_string (pp
, ", ");
3246 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3247 pp_string (pp
, " > ");
3250 case VEC_PACK_FIX_TRUNC_EXPR
:
3251 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3252 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3253 pp_string (pp
, ", ");
3254 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3255 pp_string (pp
, " > ");
3259 dump_block_node (pp
, node
, spc
, flags
);
3262 case DEBUG_BEGIN_STMT
:
3263 pp_string (pp
, "# DEBUG BEGIN STMT");
3270 if (is_stmt
&& is_expr
)
3276 /* Print the declaration of a variable. */
3279 print_declaration (pretty_printer
*pp
, tree t
, int spc
, dump_flags_t flags
)
3283 if (TREE_CODE(t
) == NAMELIST_DECL
)
3285 pp_string(pp
, "namelist ");
3286 dump_decl_name (pp
, t
, flags
);
3291 if (TREE_CODE (t
) == TYPE_DECL
)
3292 pp_string (pp
, "typedef ");
3294 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3295 pp_string (pp
, "register ");
3297 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3298 pp_string (pp
, "extern ");
3299 else if (TREE_STATIC (t
))
3300 pp_string (pp
, "static ");
3302 /* Print the type and name. */
3303 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3307 /* Print array's type. */
3308 tmp
= TREE_TYPE (t
);
3309 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3310 tmp
= TREE_TYPE (tmp
);
3311 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3313 /* Print variable's name. */
3315 dump_generic_node (pp
, t
, spc
, flags
, false);
3317 /* Print the dimensions. */
3318 tmp
= TREE_TYPE (t
);
3319 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3321 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3322 tmp
= TREE_TYPE (tmp
);
3325 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3327 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3329 dump_decl_name (pp
, t
, flags
);
3330 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3334 /* Print type declaration. */
3335 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3337 /* Print variable's name. */
3339 dump_generic_node (pp
, t
, spc
, flags
, false);
3342 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
3344 pp_string (pp
, " __asm__ ");
3346 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3347 pp_right_paren (pp
);
3350 /* The initial value of a function serves to determine whether the function
3351 is declared or defined. So the following does not apply to function
3353 if (TREE_CODE (t
) != FUNCTION_DECL
)
3355 /* Print the initial value. */
3356 if (DECL_INITIAL (t
))
3361 if (!(flags
& TDF_SLIM
))
3362 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3364 pp_string (pp
, "<<< omitted >>>");
3368 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3370 pp_string (pp
, " [value-expr: ");
3371 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3372 pp_right_bracket (pp
);
3379 /* Prints a structure: name, fields, and methods.
3380 FIXME: Still incomplete. */
3383 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
3386 /* Print the name of the structure. */
3387 if (TYPE_NAME (node
))
3390 if (TREE_CODE (node
) == RECORD_TYPE
)
3391 pp_string (pp
, "struct ");
3392 else if ((TREE_CODE (node
) == UNION_TYPE
3393 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3394 pp_string (pp
, "union ");
3396 dump_generic_node (pp
, TYPE_NAME (node
), spc
, 0, false);
3399 /* Print the contents of the structure. */
3405 /* Print the fields of the structure. */
3408 tmp
= TYPE_FIELDS (node
);
3411 /* Avoid to print recursively the structure. */
3412 /* FIXME : Not implemented correctly...,
3413 what about the case when we have a cycle in the contain graph? ...
3414 Maybe this could be solved by looking at the scope in which the
3415 structure was declared. */
3416 if (TREE_TYPE (tmp
) != node
3417 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3418 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3420 print_declaration (pp
, tmp
, spc
+2, flags
);
3423 tmp
= DECL_CHAIN (tmp
);
3427 pp_right_brace (pp
);
3430 /* Return the priority of the operator CODE.
3432 From lowest to highest precedence with either left-to-right (L-R)
3433 or right-to-left (R-L) associativity]:
3436 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3448 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3449 15 [L-R] fn() [] -> .
3451 unary +, - and * have higher precedence than the corresponding binary
3455 op_code_prio (enum tree_code code
)
3472 case TRUTH_ORIF_EXPR
:
3475 case TRUTH_AND_EXPR
:
3476 case TRUTH_ANDIF_EXPR
:
3483 case TRUTH_XOR_EXPR
:
3500 case UNORDERED_EXPR
:
3511 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3512 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3513 case WIDEN_LSHIFT_EXPR
:
3516 case WIDEN_SUM_EXPR
:
3518 case POINTER_PLUS_EXPR
:
3519 case POINTER_DIFF_EXPR
:
3523 case VEC_WIDEN_MULT_HI_EXPR
:
3524 case VEC_WIDEN_MULT_LO_EXPR
:
3525 case WIDEN_MULT_EXPR
:
3527 case WIDEN_MULT_PLUS_EXPR
:
3528 case WIDEN_MULT_MINUS_EXPR
:
3530 case MULT_HIGHPART_EXPR
:
3531 case TRUNC_DIV_EXPR
:
3533 case FLOOR_DIV_EXPR
:
3534 case ROUND_DIV_EXPR
:
3536 case EXACT_DIV_EXPR
:
3537 case TRUNC_MOD_EXPR
:
3539 case FLOOR_MOD_EXPR
:
3540 case ROUND_MOD_EXPR
:
3544 case TRUTH_NOT_EXPR
:
3546 case POSTINCREMENT_EXPR
:
3547 case POSTDECREMENT_EXPR
:
3548 case PREINCREMENT_EXPR
:
3549 case PREDECREMENT_EXPR
:
3555 case FIX_TRUNC_EXPR
:
3561 case ARRAY_RANGE_REF
:
3565 /* Special expressions. */
3571 case VEC_UNPACK_HI_EXPR
:
3572 case VEC_UNPACK_LO_EXPR
:
3573 case VEC_UNPACK_FLOAT_HI_EXPR
:
3574 case VEC_UNPACK_FLOAT_LO_EXPR
:
3575 case VEC_PACK_TRUNC_EXPR
:
3576 case VEC_PACK_SAT_EXPR
:
3580 /* Return an arbitrarily high precedence to avoid surrounding single
3581 VAR_DECLs in ()s. */
3586 /* Return the priority of the operator OP. */
3589 op_prio (const_tree op
)
3591 enum tree_code code
;
3596 code
= TREE_CODE (op
);
3597 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3598 return op_prio (TREE_OPERAND (op
, 0));
3600 return op_code_prio (code
);
3603 /* Return the symbol associated with operator CODE. */
3606 op_symbol_code (enum tree_code code
)
3614 case TRUTH_ORIF_EXPR
:
3617 case TRUTH_AND_EXPR
:
3618 case TRUTH_ANDIF_EXPR
:
3624 case TRUTH_XOR_EXPR
:
3634 case UNORDERED_EXPR
:
3680 case WIDEN_LSHIFT_EXPR
:
3683 case POINTER_PLUS_EXPR
:
3689 case WIDEN_SUM_EXPR
:
3692 case WIDEN_MULT_EXPR
:
3695 case MULT_HIGHPART_EXPR
:
3700 case POINTER_DIFF_EXPR
:
3706 case TRUTH_NOT_EXPR
:
3713 case TRUNC_DIV_EXPR
:
3720 case FLOOR_DIV_EXPR
:
3723 case ROUND_DIV_EXPR
:
3726 case EXACT_DIV_EXPR
:
3729 case TRUNC_MOD_EXPR
:
3735 case FLOOR_MOD_EXPR
:
3738 case ROUND_MOD_EXPR
:
3741 case PREDECREMENT_EXPR
:
3744 case PREINCREMENT_EXPR
:
3747 case POSTDECREMENT_EXPR
:
3750 case POSTINCREMENT_EXPR
:
3760 return "<<< ??? >>>";
3764 /* Return the symbol associated with operator OP. */
3767 op_symbol (const_tree op
)
3769 return op_symbol_code (TREE_CODE (op
));
3772 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3773 the gimple_call_fn of a GIMPLE_CALL. */
3776 print_call_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
3780 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3781 op0
= TREE_OPERAND (op0
, 0);
3784 switch (TREE_CODE (op0
))
3789 dump_function_name (pp
, op0
, flags
);
3795 op0
= TREE_OPERAND (op0
, 0);
3800 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3801 pp_string (pp
, ") ? ");
3802 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3803 pp_string (pp
, " : ");
3804 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3808 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3809 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
3811 dump_generic_node (pp
, op0
, 0, flags
, false);
3815 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3817 op0
= TREE_OPERAND (op0
, 0);
3824 dump_generic_node (pp
, op0
, 0, flags
, false);
3832 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3835 pretty_print_string (pretty_printer
*pp
, const char *str
)
3845 pp_string (pp
, "\\b");
3849 pp_string (pp
, "\\f");
3853 pp_string (pp
, "\\n");
3857 pp_string (pp
, "\\r");
3861 pp_string (pp
, "\\t");
3865 pp_string (pp
, "\\v");
3869 pp_string (pp
, "\\\\");
3873 pp_string (pp
, "\\\"");
3877 pp_string (pp
, "\\'");
3880 /* No need to handle \0; the loop terminates on \0. */
3883 pp_string (pp
, "\\1");
3887 pp_string (pp
, "\\2");
3891 pp_string (pp
, "\\3");
3895 pp_string (pp
, "\\4");
3899 pp_string (pp
, "\\5");
3903 pp_string (pp
, "\\6");
3907 pp_string (pp
, "\\7");
3911 if (!ISPRINT (str
[0]))
3914 sprintf (buf
, "\\x%x", (unsigned char)str
[0]);
3915 pp_string (pp
, buf
);
3918 pp_character (pp
, str
[0]);
3926 maybe_init_pretty_print (FILE *file
)
3930 tree_pp
= new pretty_printer ();
3931 pp_needs_newline (tree_pp
) = true;
3932 pp_translate_identifiers (tree_pp
) = false;
3935 tree_pp
->buffer
->stream
= file
;
3939 newline_and_indent (pretty_printer
*pp
, int spc
)
3945 /* Handle the %K format for TEXT. Separate from default_tree_printer
3946 so it can also be used in front ends.
3947 Argument is a statement from which EXPR_LOCATION and TREE_BLOCK will
3951 percent_K_format (text_info
*text
, tree t
)
3953 text
->set_location (0, EXPR_LOCATION (t
), true);
3954 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3955 tree block
= TREE_BLOCK (t
);
3956 *pp_ti_abstract_origin (text
) = NULL
;
3960 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3961 representing the outermost block of an inlined function.
3962 So walk the BLOCK tree until we hit such a scope. */
3964 && TREE_CODE (block
) == BLOCK
)
3966 if (inlined_function_outer_scope_p (block
))
3968 *pp_ti_abstract_origin (text
) = block
;
3971 block
= BLOCK_SUPERCONTEXT (block
);
3977 && TREE_CODE (block
) == BLOCK
3978 && BLOCK_ABSTRACT_ORIGIN (block
))
3980 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3982 while (TREE_CODE (ao
) == BLOCK
3983 && BLOCK_ABSTRACT_ORIGIN (ao
)
3984 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3985 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3987 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3989 *pp_ti_abstract_origin (text
) = block
;
3992 block
= BLOCK_SUPERCONTEXT (block
);
3996 /* Print the identifier ID to PRETTY-PRINTER. */
3999 pp_tree_identifier (pretty_printer
*pp
, tree id
)
4001 if (pp_translate_identifiers (pp
))
4003 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
4004 pp_append_text (pp
, text
, text
+ strlen (text
));
4007 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
4008 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
4011 /* A helper function that is used to dump function information before the
4015 dump_function_header (FILE *dump_file
, tree fdecl
, dump_flags_t flags
)
4017 const char *dname
, *aname
;
4018 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
4019 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
4021 dname
= lang_hooks
.decl_printable_name (fdecl
, 1);
4023 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
4024 aname
= (IDENTIFIER_POINTER
4025 (DECL_ASSEMBLER_NAME (fdecl
)));
4027 aname
= "<unset-asm-name>";
4029 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
4030 dname
, aname
, fun
->funcdef_no
);
4031 if (!(flags
& TDF_NOUID
))
4032 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
4035 fprintf (dump_file
, ", cgraph_uid=%d", node
->uid
);
4036 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
4037 node
->frequency
== NODE_FREQUENCY_HOT
4039 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
4040 ? " (unlikely executed)"
4041 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
4042 ? " (executed once)"
4046 fprintf (dump_file
, ")\n\n");
4049 /* Dump double_int D to pretty_printer PP. UNS is true
4050 if D is unsigned and false otherwise. */
4052 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4055 pp_wide_integer (pp
, d
.low
);
4056 else if (d
.fits_uhwi ())
4057 pp_unsigned_wide_integer (pp
, d
.low
);
4060 unsigned HOST_WIDE_INT low
= d
.low
;
4061 HOST_WIDE_INT high
= d
.high
;
4062 if (!uns
&& d
.is_negative ())
4065 high
= ~high
+ !low
;
4068 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4070 sprintf (pp_buffer (pp
)->digit_buffer
,
4071 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4072 (unsigned HOST_WIDE_INT
) high
, low
);
4073 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);