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