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_no_vector_kind
:
2637 pp_string (pp
, ", no-vector");
2639 case annot_expr_vector_kind
:
2640 pp_string (pp
, ", vector");
2642 case annot_expr_parallel_kind
:
2643 pp_string (pp
, ", parallel");
2652 pp_string (pp
, "return");
2653 op0
= TREE_OPERAND (node
, 0);
2657 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2658 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2661 dump_generic_node (pp
, op0
, spc
, flags
, false);
2666 pp_string (pp
, "if (");
2667 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2668 pp_string (pp
, ") break");
2672 pp_string (pp
, "switch (");
2673 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2674 pp_right_paren (pp
);
2675 if (!(flags
& TDF_SLIM
))
2677 newline_and_indent (pp
, spc
+2);
2679 if (SWITCH_BODY (node
))
2681 newline_and_indent (pp
, spc
+4);
2682 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2687 tree vec
= SWITCH_LABELS (node
);
2688 size_t i
, n
= TREE_VEC_LENGTH (vec
);
2689 for (i
= 0; i
< n
; ++i
)
2691 tree elt
= TREE_VEC_ELT (vec
, i
);
2692 newline_and_indent (pp
, spc
+4);
2695 dump_generic_node (pp
, elt
, spc
+4, flags
, false);
2696 pp_string (pp
, " goto ");
2697 dump_generic_node (pp
, CASE_LABEL (elt
), spc
+4,
2702 pp_string (pp
, "case ???: goto ???;");
2705 newline_and_indent (pp
, spc
+2);
2706 pp_right_brace (pp
);
2712 op0
= GOTO_DESTINATION (node
);
2713 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2715 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2716 if (strcmp (name
, "break") == 0
2717 || strcmp (name
, "continue") == 0)
2719 pp_string (pp
, name
);
2723 pp_string (pp
, "goto ");
2724 dump_generic_node (pp
, op0
, spc
, flags
, false);
2728 pp_string (pp
, "__asm__");
2729 if (ASM_VOLATILE_P (node
))
2730 pp_string (pp
, " __volatile__");
2732 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2734 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2736 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2737 if (ASM_CLOBBERS (node
))
2740 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2742 pp_right_paren (pp
);
2745 case CASE_LABEL_EXPR
:
2746 if (CASE_LOW (node
) && CASE_HIGH (node
))
2748 pp_string (pp
, "case ");
2749 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2750 pp_string (pp
, " ... ");
2751 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2753 else if (CASE_LOW (node
))
2755 pp_string (pp
, "case ");
2756 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2759 pp_string (pp
, "default");
2764 pp_string (pp
, "OBJ_TYPE_REF(");
2765 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2767 /* We omit the class type for -fcompare-debug because we may
2768 drop TYPE_BINFO early depending on debug info, and then
2769 virtual_method_call_p would return false, whereas when
2770 TYPE_BINFO is preserved it may still return true and then
2771 we'd print the class type. Compare tree and rtl dumps for
2772 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
2773 for example, at occurrences of OBJ_TYPE_REF. */
2774 if (!(flags
& (TDF_SLIM
| TDF_COMPARE_DEBUG
))
2775 && virtual_method_call_p (node
))
2777 pp_string (pp
, "(");
2778 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2779 pp_string (pp
, ")");
2781 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2783 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2784 pp_right_paren (pp
);
2788 if (SSA_NAME_IDENTIFIER (node
))
2790 if ((flags
& TDF_NOUID
)
2791 && SSA_NAME_VAR (node
)
2792 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
2793 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
2794 else if (! (flags
& TDF_GIMPLE
)
2795 || SSA_NAME_VAR (node
))
2796 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2800 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2801 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2802 pp_string (pp
, "(D)");
2803 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2804 pp_string (pp
, "(ab)");
2807 case WITH_SIZE_EXPR
:
2808 pp_string (pp
, "WITH_SIZE_EXPR <");
2809 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2810 pp_string (pp
, ", ");
2811 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2816 pp_string (pp
, "ASSERT_EXPR <");
2817 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2818 pp_string (pp
, ", ");
2819 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2824 pp_string (pp
, "scev_known");
2827 case SCEV_NOT_KNOWN
:
2828 pp_string (pp
, "scev_not_known");
2831 case POLYNOMIAL_CHREC
:
2833 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2834 pp_string (pp
, ", +, ");
2835 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2836 pp_printf (pp
, "}_%u", CHREC_VARIABLE (node
));
2840 case REALIGN_LOAD_EXPR
:
2841 pp_string (pp
, "REALIGN_LOAD <");
2842 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2843 pp_string (pp
, ", ");
2844 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2845 pp_string (pp
, ", ");
2846 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2851 pp_string (pp
, " VEC_COND_EXPR < ");
2852 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2853 pp_string (pp
, " , ");
2854 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2855 pp_string (pp
, " , ");
2856 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2857 pp_string (pp
, " > ");
2861 pp_string (pp
, " VEC_PERM_EXPR < ");
2862 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2863 pp_string (pp
, " , ");
2864 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2865 pp_string (pp
, " , ");
2866 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2867 pp_string (pp
, " > ");
2871 pp_string (pp
, " DOT_PROD_EXPR < ");
2872 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2873 pp_string (pp
, ", ");
2874 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2875 pp_string (pp
, ", ");
2876 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2877 pp_string (pp
, " > ");
2880 case WIDEN_MULT_PLUS_EXPR
:
2881 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
2882 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2883 pp_string (pp
, ", ");
2884 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2885 pp_string (pp
, ", ");
2886 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2887 pp_string (pp
, " > ");
2890 case WIDEN_MULT_MINUS_EXPR
:
2891 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
2892 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2893 pp_string (pp
, ", ");
2894 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2895 pp_string (pp
, ", ");
2896 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2897 pp_string (pp
, " > ");
2901 pp_string (pp
, " FMA_EXPR < ");
2902 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2903 pp_string (pp
, ", ");
2904 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2905 pp_string (pp
, ", ");
2906 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2907 pp_string (pp
, " > ");
2911 pp_string (pp
, "#pragma acc parallel");
2912 goto dump_omp_clauses_body
;
2915 pp_string (pp
, "#pragma acc kernels");
2916 goto dump_omp_clauses_body
;
2919 pp_string (pp
, "#pragma acc data");
2920 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2923 case OACC_HOST_DATA
:
2924 pp_string (pp
, "#pragma acc host_data");
2925 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2929 pp_string (pp
, "#pragma acc declare");
2930 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2934 pp_string (pp
, "#pragma acc update");
2935 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2938 case OACC_ENTER_DATA
:
2939 pp_string (pp
, "#pragma acc enter data");
2940 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2943 case OACC_EXIT_DATA
:
2944 pp_string (pp
, "#pragma acc exit data");
2945 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2949 pp_string (pp
, "#pragma acc cache");
2950 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2954 pp_string (pp
, "#pragma omp parallel");
2955 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2958 dump_omp_clauses_body
:
2959 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2963 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2965 newline_and_indent (pp
, spc
+ 2);
2967 newline_and_indent (pp
, spc
+ 4);
2968 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2969 newline_and_indent (pp
, spc
+ 2);
2970 pp_right_brace (pp
);
2976 pp_string (pp
, "#pragma omp task");
2977 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2981 pp_string (pp
, "#pragma omp for");
2985 pp_string (pp
, "#pragma omp simd");
2989 pp_string (pp
, "#pragma simd");
2993 /* This label points one line after dumping the clauses.
2994 For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2995 parameters are printed out. */
2996 goto dump_omp_loop_cilk_for
;
2998 case OMP_DISTRIBUTE
:
2999 pp_string (pp
, "#pragma omp distribute");
3003 pp_string (pp
, "#pragma omp taskloop");
3007 pp_string (pp
, "#pragma acc loop");
3011 pp_string (pp
, "#pragma omp teams");
3012 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
3015 case OMP_TARGET_DATA
:
3016 pp_string (pp
, "#pragma omp target data");
3017 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
3020 case OMP_TARGET_ENTER_DATA
:
3021 pp_string (pp
, "#pragma omp target enter data");
3022 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3026 case OMP_TARGET_EXIT_DATA
:
3027 pp_string (pp
, "#pragma omp target exit data");
3028 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3033 pp_string (pp
, "#pragma omp target");
3034 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3037 case OMP_TARGET_UPDATE
:
3038 pp_string (pp
, "#pragma omp target update");
3039 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3044 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3046 dump_omp_loop_cilk_for
:
3047 if (!(flags
& TDF_SLIM
))
3051 if (OMP_FOR_PRE_BODY (node
))
3053 if (TREE_CODE (node
) == CILK_FOR
)
3054 pp_string (pp
, " ");
3056 newline_and_indent (pp
, spc
+ 2);
3059 newline_and_indent (pp
, spc
);
3060 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3063 if (OMP_FOR_INIT (node
))
3066 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3069 if (TREE_CODE (node
) != CILK_FOR
|| OMP_FOR_PRE_BODY (node
))
3070 newline_and_indent (pp
, spc
);
3071 if (TREE_CODE (node
) == CILK_FOR
)
3072 pp_string (pp
, "_Cilk_for (");
3074 pp_string (pp
, "for (");
3075 dump_generic_node (pp
,
3076 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
3078 pp_string (pp
, "; ");
3079 dump_generic_node (pp
,
3080 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
3082 pp_string (pp
, "; ");
3083 dump_generic_node (pp
,
3084 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3086 pp_right_paren (pp
);
3088 if (TREE_CODE (node
) == CILK_FOR
)
3089 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3091 if (OMP_FOR_BODY (node
))
3093 newline_and_indent (pp
, spc
+ 2);
3095 newline_and_indent (pp
, spc
+ 4);
3096 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3098 newline_and_indent (pp
, spc
+ 2);
3099 pp_right_brace (pp
);
3101 if (OMP_FOR_INIT (node
))
3102 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3103 if (OMP_FOR_PRE_BODY (node
))
3106 newline_and_indent (pp
, spc
+ 2);
3107 pp_right_brace (pp
);
3114 pp_string (pp
, "#pragma omp sections");
3115 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3119 pp_string (pp
, "#pragma omp section");
3123 pp_string (pp
, "#pragma omp master");
3127 pp_string (pp
, "#pragma omp taskgroup");
3131 pp_string (pp
, "#pragma omp ordered");
3132 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3136 pp_string (pp
, "#pragma omp critical");
3137 if (OMP_CRITICAL_NAME (node
))
3141 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3143 pp_right_paren (pp
);
3145 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3149 pp_string (pp
, "#pragma omp atomic");
3150 if (OMP_ATOMIC_SEQ_CST (node
))
3151 pp_string (pp
, " seq_cst");
3152 newline_and_indent (pp
, spc
+ 2);
3153 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3157 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3160 case OMP_ATOMIC_READ
:
3161 pp_string (pp
, "#pragma omp atomic read");
3162 if (OMP_ATOMIC_SEQ_CST (node
))
3163 pp_string (pp
, " seq_cst");
3164 newline_and_indent (pp
, spc
+ 2);
3165 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3169 case OMP_ATOMIC_CAPTURE_OLD
:
3170 case OMP_ATOMIC_CAPTURE_NEW
:
3171 pp_string (pp
, "#pragma omp atomic capture");
3172 if (OMP_ATOMIC_SEQ_CST (node
))
3173 pp_string (pp
, " seq_cst");
3174 newline_and_indent (pp
, spc
+ 2);
3175 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3179 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3183 pp_string (pp
, "#pragma omp single");
3184 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3188 dump_omp_clause (pp
, node
, spc
, flags
);
3192 case TRANSACTION_EXPR
:
3193 if (TRANSACTION_EXPR_OUTER (node
))
3194 pp_string (pp
, "__transaction_atomic [[outer]]");
3195 else if (TRANSACTION_EXPR_RELAXED (node
))
3196 pp_string (pp
, "__transaction_relaxed");
3198 pp_string (pp
, "__transaction_atomic");
3199 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3201 newline_and_indent (pp
, spc
);
3203 newline_and_indent (pp
, spc
+ 2);
3204 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3205 spc
+ 2, flags
, false);
3206 newline_and_indent (pp
, spc
);
3207 pp_right_brace (pp
);
3212 case VEC_WIDEN_MULT_HI_EXPR
:
3213 case VEC_WIDEN_MULT_LO_EXPR
:
3214 case VEC_WIDEN_MULT_EVEN_EXPR
:
3215 case VEC_WIDEN_MULT_ODD_EXPR
:
3216 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3217 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3219 for (str
= get_tree_code_name (code
); *str
; str
++)
3220 pp_character (pp
, TOUPPER (*str
));
3221 pp_string (pp
, " < ");
3222 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3223 pp_string (pp
, ", ");
3224 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3225 pp_string (pp
, " > ");
3228 case VEC_UNPACK_HI_EXPR
:
3229 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3230 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3231 pp_string (pp
, " > ");
3234 case VEC_UNPACK_LO_EXPR
:
3235 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3236 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3237 pp_string (pp
, " > ");
3240 case VEC_UNPACK_FLOAT_HI_EXPR
:
3241 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3242 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3243 pp_string (pp
, " > ");
3246 case VEC_UNPACK_FLOAT_LO_EXPR
:
3247 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3248 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3249 pp_string (pp
, " > ");
3252 case VEC_PACK_TRUNC_EXPR
:
3253 pp_string (pp
, " VEC_PACK_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
, " > ");
3260 case VEC_PACK_SAT_EXPR
:
3261 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3262 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3263 pp_string (pp
, ", ");
3264 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3265 pp_string (pp
, " > ");
3268 case VEC_PACK_FIX_TRUNC_EXPR
:
3269 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3270 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3271 pp_string (pp
, ", ");
3272 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3273 pp_string (pp
, " > ");
3277 dump_block_node (pp
, node
, spc
, flags
);
3280 case CILK_SPAWN_STMT
:
3281 pp_string (pp
, "_Cilk_spawn ");
3282 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3285 case CILK_SYNC_STMT
:
3286 pp_string (pp
, "_Cilk_sync");
3293 if (is_stmt
&& is_expr
)
3299 /* Print the declaration of a variable. */
3302 print_declaration (pretty_printer
*pp
, tree t
, int spc
, dump_flags_t flags
)
3306 if (TREE_CODE(t
) == NAMELIST_DECL
)
3308 pp_string(pp
, "namelist ");
3309 dump_decl_name (pp
, t
, flags
);
3314 if (TREE_CODE (t
) == TYPE_DECL
)
3315 pp_string (pp
, "typedef ");
3317 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3318 pp_string (pp
, "register ");
3320 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3321 pp_string (pp
, "extern ");
3322 else if (TREE_STATIC (t
))
3323 pp_string (pp
, "static ");
3325 /* Print the type and name. */
3326 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3330 /* Print array's type. */
3331 tmp
= TREE_TYPE (t
);
3332 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3333 tmp
= TREE_TYPE (tmp
);
3334 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3336 /* Print variable's name. */
3338 dump_generic_node (pp
, t
, spc
, flags
, false);
3340 /* Print the dimensions. */
3341 tmp
= TREE_TYPE (t
);
3342 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3344 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3345 tmp
= TREE_TYPE (tmp
);
3348 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3350 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3352 dump_decl_name (pp
, t
, flags
);
3353 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3357 /* Print type declaration. */
3358 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3360 /* Print variable's name. */
3362 dump_generic_node (pp
, t
, spc
, flags
, false);
3365 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
3367 pp_string (pp
, " __asm__ ");
3369 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3370 pp_right_paren (pp
);
3373 /* The initial value of a function serves to determine whether the function
3374 is declared or defined. So the following does not apply to function
3376 if (TREE_CODE (t
) != FUNCTION_DECL
)
3378 /* Print the initial value. */
3379 if (DECL_INITIAL (t
))
3384 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3388 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3390 pp_string (pp
, " [value-expr: ");
3391 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3392 pp_right_bracket (pp
);
3399 /* Prints a structure: name, fields, and methods.
3400 FIXME: Still incomplete. */
3403 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
3406 /* Print the name of the structure. */
3407 if (TYPE_NAME (node
))
3410 if (TREE_CODE (node
) == RECORD_TYPE
)
3411 pp_string (pp
, "struct ");
3412 else if ((TREE_CODE (node
) == UNION_TYPE
3413 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3414 pp_string (pp
, "union ");
3416 dump_generic_node (pp
, TYPE_NAME (node
), spc
, 0, false);
3419 /* Print the contents of the structure. */
3425 /* Print the fields of the structure. */
3428 tmp
= TYPE_FIELDS (node
);
3431 /* Avoid to print recursively the structure. */
3432 /* FIXME : Not implemented correctly...,
3433 what about the case when we have a cycle in the contain graph? ...
3434 Maybe this could be solved by looking at the scope in which the
3435 structure was declared. */
3436 if (TREE_TYPE (tmp
) != node
3437 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3438 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3440 print_declaration (pp
, tmp
, spc
+2, flags
);
3443 tmp
= DECL_CHAIN (tmp
);
3447 pp_right_brace (pp
);
3450 /* Return the priority of the operator CODE.
3452 From lowest to highest precedence with either left-to-right (L-R)
3453 or right-to-left (R-L) associativity]:
3456 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3468 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3469 15 [L-R] fn() [] -> .
3471 unary +, - and * have higher precedence than the corresponding binary
3475 op_code_prio (enum tree_code code
)
3492 case TRUTH_ORIF_EXPR
:
3495 case TRUTH_AND_EXPR
:
3496 case TRUTH_ANDIF_EXPR
:
3503 case TRUTH_XOR_EXPR
:
3520 case UNORDERED_EXPR
:
3531 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3532 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3533 case WIDEN_LSHIFT_EXPR
:
3536 case WIDEN_SUM_EXPR
:
3538 case POINTER_PLUS_EXPR
:
3539 case POINTER_DIFF_EXPR
:
3543 case VEC_WIDEN_MULT_HI_EXPR
:
3544 case VEC_WIDEN_MULT_LO_EXPR
:
3545 case WIDEN_MULT_EXPR
:
3547 case WIDEN_MULT_PLUS_EXPR
:
3548 case WIDEN_MULT_MINUS_EXPR
:
3550 case MULT_HIGHPART_EXPR
:
3551 case TRUNC_DIV_EXPR
:
3553 case FLOOR_DIV_EXPR
:
3554 case ROUND_DIV_EXPR
:
3556 case EXACT_DIV_EXPR
:
3557 case TRUNC_MOD_EXPR
:
3559 case FLOOR_MOD_EXPR
:
3560 case ROUND_MOD_EXPR
:
3564 case TRUTH_NOT_EXPR
:
3566 case POSTINCREMENT_EXPR
:
3567 case POSTDECREMENT_EXPR
:
3568 case PREINCREMENT_EXPR
:
3569 case PREDECREMENT_EXPR
:
3575 case FIX_TRUNC_EXPR
:
3581 case ARRAY_RANGE_REF
:
3585 /* Special expressions. */
3591 case VEC_UNPACK_HI_EXPR
:
3592 case VEC_UNPACK_LO_EXPR
:
3593 case VEC_UNPACK_FLOAT_HI_EXPR
:
3594 case VEC_UNPACK_FLOAT_LO_EXPR
:
3595 case VEC_PACK_TRUNC_EXPR
:
3596 case VEC_PACK_SAT_EXPR
:
3600 /* Return an arbitrarily high precedence to avoid surrounding single
3601 VAR_DECLs in ()s. */
3606 /* Return the priority of the operator OP. */
3609 op_prio (const_tree op
)
3611 enum tree_code code
;
3616 code
= TREE_CODE (op
);
3617 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3618 return op_prio (TREE_OPERAND (op
, 0));
3620 return op_code_prio (code
);
3623 /* Return the symbol associated with operator CODE. */
3626 op_symbol_code (enum tree_code code
)
3634 case TRUTH_ORIF_EXPR
:
3637 case TRUTH_AND_EXPR
:
3638 case TRUTH_ANDIF_EXPR
:
3644 case TRUTH_XOR_EXPR
:
3654 case UNORDERED_EXPR
:
3700 case WIDEN_LSHIFT_EXPR
:
3703 case POINTER_PLUS_EXPR
:
3709 case WIDEN_SUM_EXPR
:
3712 case WIDEN_MULT_EXPR
:
3715 case MULT_HIGHPART_EXPR
:
3720 case POINTER_DIFF_EXPR
:
3726 case TRUTH_NOT_EXPR
:
3733 case TRUNC_DIV_EXPR
:
3740 case FLOOR_DIV_EXPR
:
3743 case ROUND_DIV_EXPR
:
3746 case EXACT_DIV_EXPR
:
3749 case TRUNC_MOD_EXPR
:
3755 case FLOOR_MOD_EXPR
:
3758 case ROUND_MOD_EXPR
:
3761 case PREDECREMENT_EXPR
:
3764 case PREINCREMENT_EXPR
:
3767 case POSTDECREMENT_EXPR
:
3770 case POSTINCREMENT_EXPR
:
3780 return "<<< ??? >>>";
3784 /* Return the symbol associated with operator OP. */
3787 op_symbol (const_tree op
)
3789 return op_symbol_code (TREE_CODE (op
));
3792 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3793 the gimple_call_fn of a GIMPLE_CALL. */
3796 print_call_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
3800 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3801 op0
= TREE_OPERAND (op0
, 0);
3804 switch (TREE_CODE (op0
))
3809 dump_function_name (pp
, op0
, flags
);
3815 op0
= TREE_OPERAND (op0
, 0);
3820 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3821 pp_string (pp
, ") ? ");
3822 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3823 pp_string (pp
, " : ");
3824 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3828 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3829 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
3831 dump_generic_node (pp
, op0
, 0, flags
, false);
3835 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3837 op0
= TREE_OPERAND (op0
, 0);
3844 dump_generic_node (pp
, op0
, 0, flags
, false);
3852 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3855 pretty_print_string (pretty_printer
*pp
, const char *str
)
3865 pp_string (pp
, "\\b");
3869 pp_string (pp
, "\\f");
3873 pp_string (pp
, "\\n");
3877 pp_string (pp
, "\\r");
3881 pp_string (pp
, "\\t");
3885 pp_string (pp
, "\\v");
3889 pp_string (pp
, "\\\\");
3893 pp_string (pp
, "\\\"");
3897 pp_string (pp
, "\\'");
3900 /* No need to handle \0; the loop terminates on \0. */
3903 pp_string (pp
, "\\1");
3907 pp_string (pp
, "\\2");
3911 pp_string (pp
, "\\3");
3915 pp_string (pp
, "\\4");
3919 pp_string (pp
, "\\5");
3923 pp_string (pp
, "\\6");
3927 pp_string (pp
, "\\7");
3931 if (!ISPRINT (str
[0]))
3934 sprintf (buf
, "\\x%x", (unsigned char)str
[0]);
3935 pp_string (pp
, buf
);
3938 pp_character (pp
, str
[0]);
3946 maybe_init_pretty_print (FILE *file
)
3950 tree_pp
= new pretty_printer ();
3951 pp_needs_newline (tree_pp
) = true;
3952 pp_translate_identifiers (tree_pp
) = false;
3955 tree_pp
->buffer
->stream
= file
;
3959 newline_and_indent (pretty_printer
*pp
, int spc
)
3965 /* Handle the %K format for TEXT. Separate from default_tree_printer
3966 so it can also be used in front ends.
3967 Argument is a statement from which EXPR_LOCATION and TREE_BLOCK will
3971 percent_K_format (text_info
*text
, tree t
)
3973 text
->set_location (0, EXPR_LOCATION (t
), true);
3974 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3975 tree block
= TREE_BLOCK (t
);
3976 *pp_ti_abstract_origin (text
) = NULL
;
3980 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3981 representing the outermost block of an inlined function.
3982 So walk the BLOCK tree until we hit such a scope. */
3984 && TREE_CODE (block
) == BLOCK
)
3986 if (inlined_function_outer_scope_p (block
))
3988 *pp_ti_abstract_origin (text
) = block
;
3991 block
= BLOCK_SUPERCONTEXT (block
);
3997 && TREE_CODE (block
) == BLOCK
3998 && BLOCK_ABSTRACT_ORIGIN (block
))
4000 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
4002 while (TREE_CODE (ao
) == BLOCK
4003 && BLOCK_ABSTRACT_ORIGIN (ao
)
4004 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
4005 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
4007 if (TREE_CODE (ao
) == FUNCTION_DECL
)
4009 *pp_ti_abstract_origin (text
) = block
;
4012 block
= BLOCK_SUPERCONTEXT (block
);
4016 /* Print the identifier ID to PRETTY-PRINTER. */
4019 pp_tree_identifier (pretty_printer
*pp
, tree id
)
4021 if (pp_translate_identifiers (pp
))
4023 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
4024 pp_append_text (pp
, text
, text
+ strlen (text
));
4027 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
4028 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
4031 /* A helper function that is used to dump function information before the
4035 dump_function_header (FILE *dump_file
, tree fdecl
, dump_flags_t flags
)
4037 const char *dname
, *aname
;
4038 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
4039 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
4041 dname
= lang_hooks
.decl_printable_name (fdecl
, 1);
4043 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
4044 aname
= (IDENTIFIER_POINTER
4045 (DECL_ASSEMBLER_NAME (fdecl
)));
4047 aname
= "<unset-asm-name>";
4049 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
4050 dname
, aname
, fun
->funcdef_no
);
4051 if (!(flags
& TDF_NOUID
))
4052 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
4055 fprintf (dump_file
, ", cgraph_uid=%d", node
->uid
);
4056 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
4057 node
->frequency
== NODE_FREQUENCY_HOT
4059 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
4060 ? " (unlikely executed)"
4061 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
4062 ? " (executed once)"
4066 fprintf (dump_file
, ")\n\n");
4069 /* Dump double_int D to pretty_printer PP. UNS is true
4070 if D is unsigned and false otherwise. */
4072 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4075 pp_wide_integer (pp
, d
.low
);
4076 else if (d
.fits_uhwi ())
4077 pp_unsigned_wide_integer (pp
, d
.low
);
4080 unsigned HOST_WIDE_INT low
= d
.low
;
4081 HOST_WIDE_INT high
= d
.high
;
4082 if (!uns
&& d
.is_negative ())
4085 high
= ~high
+ !low
;
4088 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4090 sprintf (pp_buffer (pp
)->digit_buffer
,
4091 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4092 (unsigned HOST_WIDE_INT
) high
, low
);
4093 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);