1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2018 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
29 #include "tree-pretty-print.h"
30 #include "stor-layout.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
34 #include "internal-fn.h"
35 #include "gomp-constants.h"
38 /* Local functions, macros and variables. */
39 static const char *op_symbol (const_tree
);
40 static void pretty_print_string (pretty_printer
*, const char*);
41 static void newline_and_indent (pretty_printer
*, int);
42 static void maybe_init_pretty_print (FILE *);
43 static void print_struct_decl (pretty_printer
*, const_tree
, int, dump_flags_t
);
44 static void do_niy (pretty_printer
*, const_tree
, dump_flags_t
);
46 #define INDENT(SPACE) do { \
47 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
49 #define NIY do_niy (pp, node, flags)
51 static pretty_printer
*tree_pp
;
53 /* Try to print something for an unknown tree code. */
56 do_niy (pretty_printer
*pp
, const_tree node
, dump_flags_t flags
)
60 pp_string (pp
, "<<< Unknown tree: ");
61 pp_string (pp
, get_tree_code_name (TREE_CODE (node
)));
65 len
= TREE_OPERAND_LENGTH (node
);
66 for (i
= 0; i
< len
; ++i
)
68 newline_and_indent (pp
, 2);
69 dump_generic_node (pp
, TREE_OPERAND (node
, i
), 2, flags
, false);
73 pp_string (pp
, " >>>");
76 /* Debugging function to print out a generic expression. */
79 debug_generic_expr (tree t
)
81 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
82 fprintf (stderr
, "\n");
85 /* Debugging function to print out a generic statement. */
88 debug_generic_stmt (tree t
)
90 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
91 fprintf (stderr
, "\n");
94 /* Debugging function to print out a chain of trees . */
97 debug_tree_chain (tree t
)
103 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
104 fprintf (stderr
, " ");
108 fprintf (stderr
, "... [cycled back to ");
109 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
110 fprintf (stderr
, "]");
114 fprintf (stderr
, "\n");
117 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
119 print_generic_decl (FILE *file
, tree decl
, dump_flags_t flags
)
121 maybe_init_pretty_print (file
);
122 print_declaration (tree_pp
, decl
, 2, flags
);
123 pp_write_text_to_stream (tree_pp
);
126 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
127 to show in the dump. See TDF_* in dumpfile.h. */
130 print_generic_stmt (FILE *file
, tree t
, dump_flags_t flags
)
132 maybe_init_pretty_print (file
);
133 dump_generic_node (tree_pp
, t
, 0, flags
, true);
134 pp_newline_and_flush (tree_pp
);
137 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
138 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
142 print_generic_stmt_indented (FILE *file
, tree t
, dump_flags_t flags
, int indent
)
146 maybe_init_pretty_print (file
);
148 for (i
= 0; i
< indent
; i
++)
150 dump_generic_node (tree_pp
, t
, indent
, flags
, true);
151 pp_newline_and_flush (tree_pp
);
154 /* Print a single expression T on file FILE. FLAGS specifies details to show
155 in the dump. See TDF_* in dumpfile.h. */
158 print_generic_expr (FILE *file
, tree t
, dump_flags_t flags
)
160 maybe_init_pretty_print (file
);
161 dump_generic_node (tree_pp
, t
, 0, flags
, false);
165 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
166 in it are replaced with Dxxxx, as long as they are at the start or
167 preceded by $ and at the end or followed by $. See make_fancy_name
171 dump_fancy_name (pretty_printer
*pp
, tree name
)
174 int length
= IDENTIFIER_LENGTH (name
);
175 const char *n
= IDENTIFIER_POINTER (name
);
182 && (n
== IDENTIFIER_POINTER (name
) || n
[-1] == '$'))
185 while (ISDIGIT (n
[l
]))
187 if (n
[l
] == '\0' || n
[l
] == '$')
200 pp_tree_identifier (pp
, name
);
204 char *str
= XNEWVEC (char, length
+ 1);
207 q
= n
= IDENTIFIER_POINTER (name
);
214 && (q
== IDENTIFIER_POINTER (name
) || q
[-1] == '$'))
217 while (ISDIGIT (q
[l
]))
219 if (q
[l
] == '\0' || q
[l
] == '$')
221 memcpy (p
, n
, q
- n
);
222 memcpy (p
+ (q
- n
), "Dxxxx", 5);
232 memcpy (p
, n
, IDENTIFIER_LENGTH (name
) - (n
- IDENTIFIER_POINTER (name
)));
234 if (pp_translate_identifiers (pp
))
236 const char *text
= identifier_to_locale (str
);
237 pp_append_text (pp
, text
, text
+ strlen (text
));
240 pp_append_text (pp
, str
, str
+ length
);
244 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
248 dump_decl_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
250 tree name
= DECL_NAME (node
);
253 if ((flags
& TDF_ASMNAME
)
254 && HAS_DECL_ASSEMBLER_NAME_P (node
)
255 && DECL_ASSEMBLER_NAME_SET_P (node
))
256 pp_tree_identifier (pp
, DECL_ASSEMBLER_NAME_RAW (node
));
257 /* For -fcompare-debug don't dump DECL_NAMELESS names at all,
258 -g might have created more fancy names and their indexes
259 could get out of sync. Usually those should be DECL_IGNORED_P
260 too, SRA can create even non-DECL_IGNORED_P DECL_NAMELESS fancy
261 names, let's hope those never get out of sync after doing the
262 dump_fancy_name sanitization. */
263 else if ((flags
& TDF_COMPARE_DEBUG
)
264 && DECL_NAMELESS (node
)
265 && DECL_IGNORED_P (node
))
267 /* For DECL_NAMELESS names look for embedded uids in the
268 names and sanitize them for TDF_NOUID. */
269 else if ((flags
& TDF_NOUID
) && DECL_NAMELESS (node
))
270 dump_fancy_name (pp
, name
);
272 pp_tree_identifier (pp
, name
);
274 char uid_sep
= (flags
& TDF_GIMPLE
) ? '_' : '.';
275 if ((flags
& TDF_UID
) || name
== NULL_TREE
)
277 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
278 pp_printf (pp
, "L%c%d", uid_sep
, (int) LABEL_DECL_UID (node
));
279 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
281 if (flags
& TDF_NOUID
)
282 pp_string (pp
, "D#xxxx");
284 pp_printf (pp
, "D#%i", DEBUG_TEMP_UID (node
));
288 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
289 if (flags
& TDF_NOUID
)
290 pp_printf (pp
, "%c.xxxx", c
);
292 pp_printf (pp
, "%c%c%u", c
, uid_sep
, DECL_UID (node
));
295 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
297 if (flags
& TDF_NOUID
)
298 pp_printf (pp
, "ptD.xxxx");
300 pp_printf (pp
, "ptD.%u", DECL_PT_UID (node
));
304 /* Like the above, but used for pretty printing function calls. */
307 dump_function_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
309 if (CONVERT_EXPR_P (node
))
310 node
= TREE_OPERAND (node
, 0);
311 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
312 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
314 dump_decl_name (pp
, node
, flags
);
317 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
318 FLAGS are as in dump_generic_node. */
321 dump_function_declaration (pretty_printer
*pp
, tree node
,
322 int spc
, dump_flags_t flags
)
324 bool wrote_arg
= false;
330 /* Print the argument types. */
331 arg
= TYPE_ARG_TYPES (node
);
332 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
340 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
341 arg
= TREE_CHAIN (arg
);
344 /* Drop the trailing void_type_node if we had any previous argument. */
345 if (arg
== void_list_node
&& !wrote_arg
)
346 pp_string (pp
, "void");
347 /* Properly dump vararg function types. */
348 else if (!arg
&& wrote_arg
)
349 pp_string (pp
, ", ...");
350 /* Avoid printing any arg for unprototyped functions. */
355 /* Dump the domain associated with an array. */
358 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, dump_flags_t flags
)
360 pp_left_bracket (pp
);
363 tree min
= TYPE_MIN_VALUE (domain
);
364 tree max
= TYPE_MAX_VALUE (domain
);
367 && integer_zerop (min
)
368 && tree_fits_shwi_p (max
))
369 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
373 dump_generic_node (pp
, min
, spc
, flags
, false);
376 dump_generic_node (pp
, max
, spc
, flags
, false);
380 pp_string (pp
, "<unknown>");
381 pp_right_bracket (pp
);
385 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
386 dump_generic_node. */
389 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
393 switch (OMP_CLAUSE_CODE (clause
))
395 case OMP_CLAUSE_PRIVATE
:
398 case OMP_CLAUSE_SHARED
:
401 case OMP_CLAUSE_FIRSTPRIVATE
:
402 name
= "firstprivate";
404 case OMP_CLAUSE_LASTPRIVATE
:
405 name
= "lastprivate";
407 case OMP_CLAUSE_COPYIN
:
410 case OMP_CLAUSE_COPYPRIVATE
:
411 name
= "copyprivate";
413 case OMP_CLAUSE_UNIFORM
:
416 case OMP_CLAUSE_USE_DEVICE_PTR
:
417 name
= "use_device_ptr";
419 case OMP_CLAUSE_IS_DEVICE_PTR
:
420 name
= "is_device_ptr";
422 case OMP_CLAUSE__LOOPTEMP_
:
425 case OMP_CLAUSE_TO_DECLARE
:
428 case OMP_CLAUSE_LINK
:
432 pp_string (pp
, name
);
434 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
439 case OMP_CLAUSE_REDUCTION
:
440 pp_string (pp
, "reduction(");
441 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
444 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
447 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
453 pp_string (pp
, "if(");
454 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
456 case ERROR_MARK
: break;
457 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
458 case OMP_TASK
: pp_string (pp
, "task:"); break;
459 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
460 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
461 case OMP_TARGET
: pp_string (pp
, "target:"); break;
462 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
463 case OMP_TARGET_ENTER_DATA
:
464 pp_string (pp
, "target enter data:"); break;
465 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
466 default: gcc_unreachable ();
468 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
473 case OMP_CLAUSE_NUM_THREADS
:
474 pp_string (pp
, "num_threads(");
475 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
480 case OMP_CLAUSE_NOWAIT
:
481 pp_string (pp
, "nowait");
483 case OMP_CLAUSE_ORDERED
:
484 pp_string (pp
, "ordered");
485 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
488 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
494 case OMP_CLAUSE_DEFAULT
:
495 pp_string (pp
, "default(");
496 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
498 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
500 case OMP_CLAUSE_DEFAULT_SHARED
:
501 pp_string (pp
, "shared");
503 case OMP_CLAUSE_DEFAULT_NONE
:
504 pp_string (pp
, "none");
506 case OMP_CLAUSE_DEFAULT_PRIVATE
:
507 pp_string (pp
, "private");
509 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
510 pp_string (pp
, "firstprivate");
512 case OMP_CLAUSE_DEFAULT_PRESENT
:
513 pp_string (pp
, "present");
521 case OMP_CLAUSE_SCHEDULE
:
522 pp_string (pp
, "schedule(");
523 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
524 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
525 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
527 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
528 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
529 pp_string (pp
, "monotonic");
531 pp_string (pp
, "nonmonotonic");
532 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
537 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
538 pp_string (pp
, "simd:");
540 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
542 case OMP_CLAUSE_SCHEDULE_STATIC
:
543 pp_string (pp
, "static");
545 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
546 pp_string (pp
, "dynamic");
548 case OMP_CLAUSE_SCHEDULE_GUIDED
:
549 pp_string (pp
, "guided");
551 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
552 pp_string (pp
, "runtime");
554 case OMP_CLAUSE_SCHEDULE_AUTO
:
555 pp_string (pp
, "auto");
560 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
563 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
569 case OMP_CLAUSE_UNTIED
:
570 pp_string (pp
, "untied");
573 case OMP_CLAUSE_COLLAPSE
:
574 pp_string (pp
, "collapse(");
575 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
580 case OMP_CLAUSE_FINAL
:
581 pp_string (pp
, "final(");
582 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
587 case OMP_CLAUSE_MERGEABLE
:
588 pp_string (pp
, "mergeable");
591 case OMP_CLAUSE_LINEAR
:
592 pp_string (pp
, "linear(");
593 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
595 case OMP_CLAUSE_LINEAR_DEFAULT
:
597 case OMP_CLAUSE_LINEAR_REF
:
598 pp_string (pp
, "ref(");
600 case OMP_CLAUSE_LINEAR_VAL
:
601 pp_string (pp
, "val(");
603 case OMP_CLAUSE_LINEAR_UVAL
:
604 pp_string (pp
, "uval(");
609 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
611 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
614 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
619 case OMP_CLAUSE_ALIGNED
:
620 pp_string (pp
, "aligned(");
621 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
623 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
626 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
632 case OMP_CLAUSE_DEPEND
:
633 pp_string (pp
, "depend(");
634 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
636 case OMP_CLAUSE_DEPEND_IN
:
637 pp_string (pp
, "in");
639 case OMP_CLAUSE_DEPEND_OUT
:
640 pp_string (pp
, "out");
642 case OMP_CLAUSE_DEPEND_INOUT
:
643 pp_string (pp
, "inout");
645 case OMP_CLAUSE_DEPEND_SOURCE
:
646 pp_string (pp
, "source)");
648 case OMP_CLAUSE_DEPEND_SINK
:
649 pp_string (pp
, "sink:");
650 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
651 if (TREE_CODE (t
) == TREE_LIST
)
653 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
654 if (TREE_PURPOSE (t
) != integer_zero_node
)
656 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
660 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
674 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
680 pp_string (pp
, "map(");
681 switch (OMP_CLAUSE_MAP_KIND (clause
))
684 case GOMP_MAP_POINTER
:
685 pp_string (pp
, "alloc");
688 case GOMP_MAP_TO_PSET
:
689 pp_string (pp
, "to");
692 pp_string (pp
, "from");
694 case GOMP_MAP_TOFROM
:
695 pp_string (pp
, "tofrom");
697 case GOMP_MAP_FORCE_ALLOC
:
698 pp_string (pp
, "force_alloc");
700 case GOMP_MAP_FORCE_TO
:
701 pp_string (pp
, "force_to");
703 case GOMP_MAP_FORCE_FROM
:
704 pp_string (pp
, "force_from");
706 case GOMP_MAP_FORCE_TOFROM
:
707 pp_string (pp
, "force_tofrom");
709 case GOMP_MAP_FORCE_PRESENT
:
710 pp_string (pp
, "force_present");
712 case GOMP_MAP_DELETE
:
713 pp_string (pp
, "delete");
715 case GOMP_MAP_FORCE_DEVICEPTR
:
716 pp_string (pp
, "force_deviceptr");
718 case GOMP_MAP_ALWAYS_TO
:
719 pp_string (pp
, "always,to");
721 case GOMP_MAP_ALWAYS_FROM
:
722 pp_string (pp
, "always,from");
724 case GOMP_MAP_ALWAYS_TOFROM
:
725 pp_string (pp
, "always,tofrom");
727 case GOMP_MAP_RELEASE
:
728 pp_string (pp
, "release");
730 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
731 pp_string (pp
, "firstprivate");
733 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
734 pp_string (pp
, "firstprivate ref");
736 case GOMP_MAP_STRUCT
:
737 pp_string (pp
, "struct");
739 case GOMP_MAP_ALWAYS_POINTER
:
740 pp_string (pp
, "always_pointer");
742 case GOMP_MAP_DEVICE_RESIDENT
:
743 pp_string (pp
, "device_resident");
746 pp_string (pp
, "link");
752 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
755 if (OMP_CLAUSE_SIZE (clause
))
757 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
758 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
760 case GOMP_MAP_POINTER
:
761 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
762 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
763 case GOMP_MAP_ALWAYS_POINTER
:
764 pp_string (pp
, " [pointer assign, bias: ");
766 case GOMP_MAP_TO_PSET
:
767 pp_string (pp
, " [pointer set, len: ");
770 pp_string (pp
, " [len: ");
773 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
775 pp_right_bracket (pp
);
780 case OMP_CLAUSE_FROM
:
781 pp_string (pp
, "from(");
782 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
784 goto print_clause_size
;
787 pp_string (pp
, "to(");
788 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
790 goto print_clause_size
;
792 case OMP_CLAUSE__CACHE_
:
794 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
796 goto print_clause_size
;
798 case OMP_CLAUSE_NUM_TEAMS
:
799 pp_string (pp
, "num_teams(");
800 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
805 case OMP_CLAUSE_THREAD_LIMIT
:
806 pp_string (pp
, "thread_limit(");
807 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
812 case OMP_CLAUSE_DEVICE
:
813 pp_string (pp
, "device(");
814 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
819 case OMP_CLAUSE_DIST_SCHEDULE
:
820 pp_string (pp
, "dist_schedule(static");
821 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
824 dump_generic_node (pp
,
825 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
831 case OMP_CLAUSE_PROC_BIND
:
832 pp_string (pp
, "proc_bind(");
833 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
835 case OMP_CLAUSE_PROC_BIND_MASTER
:
836 pp_string (pp
, "master");
838 case OMP_CLAUSE_PROC_BIND_CLOSE
:
839 pp_string (pp
, "close");
841 case OMP_CLAUSE_PROC_BIND_SPREAD
:
842 pp_string (pp
, "spread");
850 case OMP_CLAUSE_SAFELEN
:
851 pp_string (pp
, "safelen(");
852 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
857 case OMP_CLAUSE_SIMDLEN
:
858 pp_string (pp
, "simdlen(");
859 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
864 case OMP_CLAUSE_PRIORITY
:
865 pp_string (pp
, "priority(");
866 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
871 case OMP_CLAUSE_GRAINSIZE
:
872 pp_string (pp
, "grainsize(");
873 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
878 case OMP_CLAUSE_NUM_TASKS
:
879 pp_string (pp
, "num_tasks(");
880 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
885 case OMP_CLAUSE_HINT
:
886 pp_string (pp
, "hint(");
887 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
892 case OMP_CLAUSE_DEFAULTMAP
:
893 pp_string (pp
, "defaultmap(tofrom:scalar)");
896 case OMP_CLAUSE__SIMDUID_
:
897 pp_string (pp
, "_simduid_(");
898 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
903 case OMP_CLAUSE__SIMT_
:
904 pp_string (pp
, "_simt_");
907 case OMP_CLAUSE_GANG
:
908 pp_string (pp
, "gang");
909 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
911 pp_string (pp
, "(num: ");
912 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
915 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
917 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
921 pp_string (pp
, "static:");
922 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
923 == integer_minus_one_node
)
924 pp_character (pp
, '*');
926 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
929 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
930 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
934 case OMP_CLAUSE_ASYNC
:
935 pp_string (pp
, "async");
936 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
938 pp_character(pp
, '(');
939 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
941 pp_character(pp
, ')');
945 case OMP_CLAUSE_AUTO
:
947 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
950 case OMP_CLAUSE_WAIT
:
951 pp_string (pp
, "wait(");
952 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
954 pp_character(pp
, ')');
957 case OMP_CLAUSE_WORKER
:
958 pp_string (pp
, "worker");
959 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
962 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
968 case OMP_CLAUSE_VECTOR
:
969 pp_string (pp
, "vector");
970 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
973 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
979 case OMP_CLAUSE_NUM_GANGS
:
980 pp_string (pp
, "num_gangs(");
981 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
983 pp_character (pp
, ')');
986 case OMP_CLAUSE_NUM_WORKERS
:
987 pp_string (pp
, "num_workers(");
988 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
990 pp_character (pp
, ')');
993 case OMP_CLAUSE_VECTOR_LENGTH
:
994 pp_string (pp
, "vector_length(");
995 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
997 pp_character (pp
, ')');
1000 case OMP_CLAUSE_INBRANCH
:
1001 pp_string (pp
, "inbranch");
1003 case OMP_CLAUSE_NOTINBRANCH
:
1004 pp_string (pp
, "notinbranch");
1006 case OMP_CLAUSE_FOR
:
1007 pp_string (pp
, "for");
1009 case OMP_CLAUSE_PARALLEL
:
1010 pp_string (pp
, "parallel");
1012 case OMP_CLAUSE_SECTIONS
:
1013 pp_string (pp
, "sections");
1015 case OMP_CLAUSE_TASKGROUP
:
1016 pp_string (pp
, "taskgroup");
1018 case OMP_CLAUSE_NOGROUP
:
1019 pp_string (pp
, "nogroup");
1021 case OMP_CLAUSE_THREADS
:
1022 pp_string (pp
, "threads");
1024 case OMP_CLAUSE_SIMD
:
1025 pp_string (pp
, "simd");
1027 case OMP_CLAUSE_INDEPENDENT
:
1028 pp_string (pp
, "independent");
1030 case OMP_CLAUSE_TILE
:
1031 pp_string (pp
, "tile(");
1032 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1034 pp_right_paren (pp
);
1037 case OMP_CLAUSE__GRIDDIM_
:
1038 pp_string (pp
, "_griddim_(");
1039 pp_unsigned_wide_integer (pp
, OMP_CLAUSE__GRIDDIM__DIMENSION (clause
));
1041 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__SIZE (clause
), spc
, flags
,
1044 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__GROUP (clause
), spc
, flags
,
1046 pp_right_paren (pp
);
1050 /* Should never happen. */
1051 dump_generic_node (pp
, clause
, spc
, flags
, false);
1057 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1058 dump_generic_node. */
1061 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
1069 dump_omp_clause (pp
, clause
, spc
, flags
);
1070 clause
= OMP_CLAUSE_CHAIN (clause
);
1078 /* Dump location LOC to PP. */
1081 dump_location (pretty_printer
*pp
, location_t loc
)
1083 expanded_location xloc
= expand_location (loc
);
1085 pp_left_bracket (pp
);
1088 pp_string (pp
, xloc
.file
);
1089 pp_string (pp
, ":");
1091 pp_decimal_int (pp
, xloc
.line
);
1093 pp_decimal_int (pp
, xloc
.column
);
1094 pp_string (pp
, "] ");
1098 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1099 dump_generic_node. */
1102 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, dump_flags_t flags
)
1106 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1108 if (flags
& TDF_ADDRESS
)
1109 pp_printf (pp
, "[%p] ", (void *) block
);
1111 if (BLOCK_ABSTRACT (block
))
1112 pp_string (pp
, "[abstract] ");
1114 if (TREE_ASM_WRITTEN (block
))
1115 pp_string (pp
, "[written] ");
1117 if (flags
& TDF_SLIM
)
1120 if (BLOCK_SOURCE_LOCATION (block
))
1121 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1123 newline_and_indent (pp
, spc
+ 2);
1125 if (BLOCK_SUPERCONTEXT (block
))
1127 pp_string (pp
, "SUPERCONTEXT: ");
1128 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1129 flags
| TDF_SLIM
, false);
1130 newline_and_indent (pp
, spc
+ 2);
1133 if (BLOCK_SUBBLOCKS (block
))
1135 pp_string (pp
, "SUBBLOCKS: ");
1136 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1138 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1141 newline_and_indent (pp
, spc
+ 2);
1144 if (BLOCK_CHAIN (block
))
1146 pp_string (pp
, "SIBLINGS: ");
1147 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1149 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1152 newline_and_indent (pp
, spc
+ 2);
1155 if (BLOCK_VARS (block
))
1157 pp_string (pp
, "VARS: ");
1158 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1160 dump_generic_node (pp
, t
, 0, flags
, false);
1163 newline_and_indent (pp
, spc
+ 2);
1166 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1169 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1171 pp_string (pp
, "NONLOCALIZED_VARS: ");
1172 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1174 dump_generic_node (pp
, t
, 0, flags
, false);
1177 newline_and_indent (pp
, spc
+ 2);
1180 if (BLOCK_ABSTRACT_ORIGIN (block
))
1182 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1183 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1184 flags
| TDF_SLIM
, false);
1185 newline_and_indent (pp
, spc
+ 2);
1188 if (BLOCK_FRAGMENT_ORIGIN (block
))
1190 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1191 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1192 flags
| TDF_SLIM
, false);
1193 newline_and_indent (pp
, spc
+ 2);
1196 if (BLOCK_FRAGMENT_CHAIN (block
))
1198 pp_string (pp
, "FRAGMENT_CHAIN: ");
1199 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1201 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1204 newline_and_indent (pp
, spc
+ 2);
1209 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1210 indent. FLAGS specifies details to show in the dump (see TDF_* in
1211 dumpfile.h). If IS_STMT is true, the object printed is considered
1212 to be a statement and it is terminated by ';' if appropriate. */
1215 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
,
1222 enum tree_code code
;
1224 if (node
== NULL_TREE
)
1227 is_expr
= EXPR_P (node
);
1229 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1230 pp_printf (pp
, "<&%p> ", (void *)node
);
1232 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1233 dump_location (pp
, EXPR_LOCATION (node
));
1235 code
= TREE_CODE (node
);
1239 pp_string (pp
, "<<< error >>>");
1242 case IDENTIFIER_NODE
:
1243 pp_tree_identifier (pp
, node
);
1247 while (node
&& node
!= error_mark_node
)
1249 if (TREE_PURPOSE (node
))
1251 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1254 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1255 node
= TREE_CHAIN (node
);
1256 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1265 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1271 if (TREE_VEC_LENGTH (node
) > 0)
1273 size_t len
= TREE_VEC_LENGTH (node
);
1274 for (i
= 0; i
< len
- 1; i
++)
1276 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1281 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
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_IDENTIFIER (node
))
1426 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
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 pp_string (pp
, "POLY_INT_CST [");
1749 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, 0), spc
, flags
, false);
1750 for (unsigned int i
= 1; i
< NUM_POLY_INT_COEFFS
; ++i
)
1752 pp_string (pp
, ", ");
1753 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, i
),
1756 pp_string (pp
, "]");
1760 /* Code copied from print_node. */
1763 if (TREE_OVERFLOW (node
))
1764 pp_string (pp
, " overflow");
1766 d
= TREE_REAL_CST (node
);
1767 if (REAL_VALUE_ISINF (d
))
1768 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1769 else if (REAL_VALUE_ISNAN (d
))
1770 pp_string (pp
, " Nan");
1774 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1775 pp_string (pp
, string
);
1783 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1784 pp_string (pp
, string
);
1789 pp_string (pp
, "__complex__ (");
1790 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
1791 pp_string (pp
, ", ");
1792 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
1793 pp_right_paren (pp
);
1797 pp_string (pp
, "\"");
1798 pretty_print_string (pp
, TREE_STRING_POINTER (node
));
1799 pp_string (pp
, "\"");
1805 pp_string (pp
, "{ ");
1806 unsigned HOST_WIDE_INT nunits
;
1807 if (!VECTOR_CST_NELTS (node
).is_constant (&nunits
))
1808 nunits
= vector_cst_encoded_nelts (node
);
1809 for (i
= 0; i
< nunits
; ++i
)
1812 pp_string (pp
, ", ");
1813 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
1816 if (!VECTOR_CST_NELTS (node
).is_constant ())
1817 pp_string (pp
, ", ...");
1818 pp_string (pp
, " }");
1824 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1826 if (TREE_CODE (node
) == METHOD_TYPE
)
1828 if (TYPE_METHOD_BASETYPE (node
))
1829 dump_generic_node (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1832 pp_string (pp
, "<null method basetype>");
1833 pp_colon_colon (pp
);
1835 if (TYPE_IDENTIFIER (node
))
1836 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1837 else if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1838 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1839 else if (flags
& TDF_NOUID
)
1840 pp_printf (pp
, "<Txxxx>");
1842 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1843 dump_function_declaration (pp
, node
, spc
, flags
);
1848 dump_decl_name (pp
, node
, flags
);
1852 if (DECL_NAME (node
))
1853 dump_decl_name (pp
, node
, flags
);
1854 else if (LABEL_DECL_UID (node
) != -1)
1856 if (flags
& TDF_GIMPLE
)
1857 pp_printf (pp
, "L%d", (int) LABEL_DECL_UID (node
));
1859 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
1863 if (flags
& TDF_NOUID
)
1864 pp_string (pp
, "<D.xxxx>");
1867 if (flags
& TDF_GIMPLE
)
1868 pp_printf (pp
, "<D%u>", DECL_UID (node
));
1870 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
1876 if (DECL_IS_BUILTIN (node
))
1878 /* Don't print the declaration of built-in types. */
1881 if (DECL_NAME (node
))
1882 dump_decl_name (pp
, node
, flags
);
1883 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1885 pp_string (pp
, (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1886 ? "union" : "struct "));
1887 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1890 pp_string (pp
, "<anon>");
1896 case DEBUG_EXPR_DECL
:
1897 case NAMESPACE_DECL
:
1899 dump_decl_name (pp
, node
, flags
);
1903 pp_string (pp
, "<retval>");
1907 op0
= TREE_OPERAND (node
, 0);
1910 && (TREE_CODE (op0
) == INDIRECT_REF
1911 || (TREE_CODE (op0
) == MEM_REF
1912 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1913 && integer_zerop (TREE_OPERAND (op0
, 1))
1914 /* Dump the types of INTEGER_CSTs explicitly, for we
1915 can't infer them and MEM_ATTR caching will share
1916 MEM_REFs with differently-typed op0s. */
1917 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1918 /* Released SSA_NAMES have no TREE_TYPE. */
1919 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1920 /* Same pointer types, but ignoring POINTER_TYPE vs.
1922 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1923 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1924 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1925 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1926 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1927 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1928 /* Same value types ignoring qualifiers. */
1929 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1930 == TYPE_MAIN_VARIANT
1931 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
1932 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
1934 op0
= TREE_OPERAND (op0
, 0);
1937 if (op_prio (op0
) < op_prio (node
))
1939 dump_generic_node (pp
, op0
, spc
, flags
, false);
1940 if (op_prio (op0
) < op_prio (node
))
1941 pp_right_paren (pp
);
1942 pp_string (pp
, str
);
1943 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1944 op0
= component_ref_field_offset (node
);
1945 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1947 pp_string (pp
, "{off: ");
1948 dump_generic_node (pp
, op0
, spc
, flags
, false);
1949 pp_right_brace (pp
);
1954 pp_string (pp
, "BIT_FIELD_REF <");
1955 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1956 pp_string (pp
, ", ");
1957 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1958 pp_string (pp
, ", ");
1959 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1963 case BIT_INSERT_EXPR
:
1964 pp_string (pp
, "BIT_INSERT_EXPR <");
1965 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1966 pp_string (pp
, ", ");
1967 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1968 pp_string (pp
, ", ");
1969 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1970 pp_string (pp
, " (");
1971 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
1973 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
1975 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
1977 pp_string (pp
, " bits)>");
1981 case ARRAY_RANGE_REF
:
1982 op0
= TREE_OPERAND (node
, 0);
1983 if (op_prio (op0
) < op_prio (node
))
1985 dump_generic_node (pp
, op0
, spc
, flags
, false);
1986 if (op_prio (op0
) < op_prio (node
))
1987 pp_right_paren (pp
);
1988 pp_left_bracket (pp
);
1989 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1990 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1991 pp_string (pp
, " ...");
1992 pp_right_bracket (pp
);
1994 op0
= array_ref_low_bound (node
);
1995 op1
= array_ref_element_size (node
);
1997 if (!integer_zerop (op0
)
1998 || TREE_OPERAND (node
, 2)
1999 || TREE_OPERAND (node
, 3))
2001 pp_string (pp
, "{lb: ");
2002 dump_generic_node (pp
, op0
, spc
, flags
, false);
2003 pp_string (pp
, " sz: ");
2004 dump_generic_node (pp
, op1
, spc
, flags
, false);
2005 pp_right_brace (pp
);
2011 unsigned HOST_WIDE_INT ix
;
2013 bool is_struct_init
= false;
2014 bool is_array_init
= false;
2017 if (TREE_CLOBBER_P (node
))
2018 pp_string (pp
, "CLOBBER");
2019 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
2020 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
2021 is_struct_init
= true;
2022 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
2023 && TYPE_DOMAIN (TREE_TYPE (node
))
2024 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
2025 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
2028 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
2029 is_array_init
= true;
2030 curidx
= wi::to_widest (minv
);
2032 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
2039 dump_generic_node (pp
, field
, spc
, flags
, false);
2042 else if (is_array_init
2043 && (TREE_CODE (field
) != INTEGER_CST
2044 || curidx
!= wi::to_widest (field
)))
2046 pp_left_bracket (pp
);
2047 if (TREE_CODE (field
) == RANGE_EXPR
)
2049 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
2051 pp_string (pp
, " ... ");
2052 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
2054 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
2055 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
2058 dump_generic_node (pp
, field
, spc
, flags
, false);
2059 if (TREE_CODE (field
) == INTEGER_CST
)
2060 curidx
= wi::to_widest (field
);
2061 pp_string (pp
, "]=");
2066 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
2067 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
2068 val
= TREE_OPERAND (val
, 0);
2069 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
2070 dump_decl_name (pp
, val
, flags
);
2072 dump_generic_node (pp
, val
, spc
, flags
, false);
2073 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2079 pp_right_brace (pp
);
2086 if (flags
& TDF_SLIM
)
2088 pp_string (pp
, "<COMPOUND_EXPR>");
2092 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2093 spc
, flags
, !(flags
& TDF_SLIM
));
2094 if (flags
& TDF_SLIM
)
2095 newline_and_indent (pp
, spc
);
2102 for (tp
= &TREE_OPERAND (node
, 1);
2103 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2104 tp
= &TREE_OPERAND (*tp
, 1))
2106 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2107 spc
, flags
, !(flags
& TDF_SLIM
));
2108 if (flags
& TDF_SLIM
)
2109 newline_and_indent (pp
, spc
);
2117 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2121 case STATEMENT_LIST
:
2123 tree_stmt_iterator si
;
2126 if (flags
& TDF_SLIM
)
2128 pp_string (pp
, "<STATEMENT_LIST>");
2132 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2135 newline_and_indent (pp
, spc
);
2138 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2145 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2150 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2155 pp_string (pp
, "TARGET_EXPR <");
2156 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2159 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2164 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2169 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2171 pp_string (pp
, "if (");
2172 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2173 pp_right_paren (pp
);
2174 /* The lowered cond_exprs should always be printed in full. */
2175 if (COND_EXPR_THEN (node
)
2176 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2177 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2178 && COND_EXPR_ELSE (node
)
2179 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2180 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2183 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2185 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2187 pp_string (pp
, " else ");
2188 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2192 else if (!(flags
& TDF_SLIM
))
2194 /* Output COND_EXPR_THEN. */
2195 if (COND_EXPR_THEN (node
))
2197 newline_and_indent (pp
, spc
+2);
2199 newline_and_indent (pp
, spc
+4);
2200 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2202 newline_and_indent (pp
, spc
+2);
2203 pp_right_brace (pp
);
2206 /* Output COND_EXPR_ELSE. */
2207 if (COND_EXPR_ELSE (node
)
2208 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2210 newline_and_indent (pp
, spc
);
2211 pp_string (pp
, "else");
2212 newline_and_indent (pp
, spc
+2);
2214 newline_and_indent (pp
, spc
+4);
2215 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2217 newline_and_indent (pp
, spc
+2);
2218 pp_right_brace (pp
);
2225 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2229 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2233 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2239 if (!(flags
& TDF_SLIM
))
2241 if (BIND_EXPR_VARS (node
))
2245 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2247 print_declaration (pp
, op0
, spc
+2, flags
);
2252 newline_and_indent (pp
, spc
+2);
2253 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2254 newline_and_indent (pp
, spc
);
2255 pp_right_brace (pp
);
2261 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2262 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2266 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2269 /* Print parameters. */
2274 call_expr_arg_iterator iter
;
2275 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2277 dump_generic_node (pp
, arg
, spc
, flags
, false);
2278 if (more_call_expr_args_p (&iter
))
2285 if (CALL_EXPR_VA_ARG_PACK (node
))
2287 if (call_expr_nargs (node
) > 0)
2292 pp_string (pp
, "__builtin_va_arg_pack ()");
2294 pp_right_paren (pp
);
2296 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2299 pp_string (pp
, " [static-chain: ");
2300 dump_generic_node (pp
, op1
, spc
, flags
, false);
2301 pp_right_bracket (pp
);
2304 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2305 pp_string (pp
, " [return slot optimization]");
2306 if (CALL_EXPR_TAILCALL (node
))
2307 pp_string (pp
, " [tail call]");
2310 case WITH_CLEANUP_EXPR
:
2314 case CLEANUP_POINT_EXPR
:
2315 pp_string (pp
, "<<cleanup_point ");
2316 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2317 pp_string (pp
, ">>");
2320 case PLACEHOLDER_EXPR
:
2321 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2322 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2326 /* Binary arithmetic and logic expressions. */
2327 case WIDEN_SUM_EXPR
:
2328 case WIDEN_MULT_EXPR
:
2330 case MULT_HIGHPART_EXPR
:
2332 case POINTER_PLUS_EXPR
:
2333 case POINTER_DIFF_EXPR
:
2335 case TRUNC_DIV_EXPR
:
2337 case FLOOR_DIV_EXPR
:
2338 case ROUND_DIV_EXPR
:
2339 case TRUNC_MOD_EXPR
:
2341 case FLOOR_MOD_EXPR
:
2342 case ROUND_MOD_EXPR
:
2344 case EXACT_DIV_EXPR
:
2349 case WIDEN_LSHIFT_EXPR
:
2353 case TRUTH_ANDIF_EXPR
:
2354 case TRUTH_ORIF_EXPR
:
2355 case TRUTH_AND_EXPR
:
2357 case TRUTH_XOR_EXPR
:
2371 case UNORDERED_EXPR
:
2373 const char *op
= op_symbol (node
);
2374 op0
= TREE_OPERAND (node
, 0);
2375 op1
= TREE_OPERAND (node
, 1);
2377 /* When the operands are expressions with less priority,
2378 keep semantics of the tree representation. */
2379 if (op_prio (op0
) <= op_prio (node
))
2382 dump_generic_node (pp
, op0
, spc
, flags
, false);
2383 pp_right_paren (pp
);
2386 dump_generic_node (pp
, op0
, spc
, flags
, false);
2392 /* When the operands are expressions with less priority,
2393 keep semantics of the tree representation. */
2394 if (op_prio (op1
) <= op_prio (node
))
2397 dump_generic_node (pp
, op1
, spc
, flags
, false);
2398 pp_right_paren (pp
);
2401 dump_generic_node (pp
, op1
, spc
, flags
, false);
2405 /* Unary arithmetic and logic expressions. */
2408 case TRUTH_NOT_EXPR
:
2410 case PREDECREMENT_EXPR
:
2411 case PREINCREMENT_EXPR
:
2413 if (TREE_CODE (node
) == ADDR_EXPR
2414 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2415 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2416 ; /* Do not output '&' for strings and function pointers. */
2418 pp_string (pp
, op_symbol (node
));
2420 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2423 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2424 pp_right_paren (pp
);
2427 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2430 case POSTDECREMENT_EXPR
:
2431 case POSTINCREMENT_EXPR
:
2432 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2435 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2436 pp_right_paren (pp
);
2439 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2440 pp_string (pp
, op_symbol (node
));
2444 pp_string (pp
, "MIN_EXPR <");
2445 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2446 pp_string (pp
, ", ");
2447 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2452 pp_string (pp
, "MAX_EXPR <");
2453 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2454 pp_string (pp
, ", ");
2455 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2460 pp_string (pp
, "ABS_EXPR <");
2461 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2469 case ADDR_SPACE_CONVERT_EXPR
:
2470 case FIXED_CONVERT_EXPR
:
2471 case FIX_TRUNC_EXPR
:
2474 type
= TREE_TYPE (node
);
2475 op0
= TREE_OPERAND (node
, 0);
2476 if (type
!= TREE_TYPE (op0
))
2479 dump_generic_node (pp
, type
, spc
, flags
, false);
2480 pp_string (pp
, ") ");
2482 if (op_prio (op0
) < op_prio (node
))
2484 dump_generic_node (pp
, op0
, spc
, flags
, false);
2485 if (op_prio (op0
) < op_prio (node
))
2486 pp_right_paren (pp
);
2489 case VIEW_CONVERT_EXPR
:
2490 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2491 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2492 pp_string (pp
, ">(");
2493 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2494 pp_right_paren (pp
);
2498 pp_string (pp
, "((");
2499 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2500 pp_string (pp
, "))");
2503 case NON_LVALUE_EXPR
:
2504 pp_string (pp
, "NON_LVALUE_EXPR <");
2505 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2510 pp_string (pp
, "SAVE_EXPR <");
2511 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2516 pp_string (pp
, "COMPLEX_EXPR <");
2517 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2518 pp_string (pp
, ", ");
2519 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2524 pp_string (pp
, "CONJ_EXPR <");
2525 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2530 if (flags
& TDF_GIMPLE
)
2532 pp_string (pp
, "__real ");
2533 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2537 pp_string (pp
, "REALPART_EXPR <");
2538 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2544 if (flags
& TDF_GIMPLE
)
2546 pp_string (pp
, "__imag ");
2547 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2551 pp_string (pp
, "IMAGPART_EXPR <");
2552 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2558 pp_string (pp
, "VA_ARG_EXPR <");
2559 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2563 case TRY_FINALLY_EXPR
:
2564 case TRY_CATCH_EXPR
:
2565 pp_string (pp
, "try");
2566 newline_and_indent (pp
, spc
+2);
2568 newline_and_indent (pp
, spc
+4);
2569 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2570 newline_and_indent (pp
, spc
+2);
2571 pp_right_brace (pp
);
2572 newline_and_indent (pp
, spc
);
2574 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2575 newline_and_indent (pp
, spc
+2);
2577 newline_and_indent (pp
, spc
+4);
2578 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2579 newline_and_indent (pp
, spc
+2);
2580 pp_right_brace (pp
);
2585 pp_string (pp
, "catch (");
2586 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2587 pp_right_paren (pp
);
2588 newline_and_indent (pp
, spc
+2);
2590 newline_and_indent (pp
, spc
+4);
2591 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2592 newline_and_indent (pp
, spc
+2);
2593 pp_right_brace (pp
);
2597 case EH_FILTER_EXPR
:
2598 pp_string (pp
, "<<<eh_filter (");
2599 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2600 pp_string (pp
, ")>>>");
2601 newline_and_indent (pp
, spc
+2);
2603 newline_and_indent (pp
, spc
+4);
2604 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2605 newline_and_indent (pp
, spc
+2);
2606 pp_right_brace (pp
);
2611 op0
= TREE_OPERAND (node
, 0);
2612 /* If this is for break or continue, don't bother printing it. */
2613 if (DECL_NAME (op0
))
2615 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2616 if (strcmp (name
, "break") == 0
2617 || strcmp (name
, "continue") == 0)
2620 dump_generic_node (pp
, op0
, spc
, flags
, false);
2622 if (DECL_NONLOCAL (op0
))
2623 pp_string (pp
, " [non-local]");
2627 pp_string (pp
, "while (1)");
2628 if (!(flags
& TDF_SLIM
))
2630 newline_and_indent (pp
, spc
+2);
2632 newline_and_indent (pp
, spc
+4);
2633 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2634 newline_and_indent (pp
, spc
+2);
2635 pp_right_brace (pp
);
2641 pp_string (pp
, "// predicted ");
2642 if (PREDICT_EXPR_OUTCOME (node
))
2643 pp_string (pp
, "likely by ");
2645 pp_string (pp
, "unlikely by ");
2646 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2647 pp_string (pp
, " predictor.");
2651 pp_string (pp
, "ANNOTATE_EXPR <");
2652 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2653 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2655 case annot_expr_ivdep_kind
:
2656 pp_string (pp
, ", ivdep");
2658 case annot_expr_unroll_kind
:
2659 pp_printf (pp
, ", unroll %d",
2660 (int) TREE_INT_CST_LOW (TREE_OPERAND (node
, 2)));
2662 case annot_expr_no_vector_kind
:
2663 pp_string (pp
, ", no-vector");
2665 case annot_expr_vector_kind
:
2666 pp_string (pp
, ", vector");
2668 case annot_expr_parallel_kind
:
2669 pp_string (pp
, ", parallel");
2678 pp_string (pp
, "return");
2679 op0
= TREE_OPERAND (node
, 0);
2683 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2684 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2687 dump_generic_node (pp
, op0
, spc
, flags
, false);
2692 pp_string (pp
, "if (");
2693 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2694 pp_string (pp
, ") break");
2698 pp_string (pp
, "switch (");
2699 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2700 pp_right_paren (pp
);
2701 if (!(flags
& TDF_SLIM
))
2703 newline_and_indent (pp
, spc
+2);
2705 if (SWITCH_BODY (node
))
2707 newline_and_indent (pp
, spc
+4);
2708 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2711 newline_and_indent (pp
, spc
+2);
2712 pp_right_brace (pp
);
2718 op0
= GOTO_DESTINATION (node
);
2719 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2721 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2722 if (strcmp (name
, "break") == 0
2723 || strcmp (name
, "continue") == 0)
2725 pp_string (pp
, name
);
2729 pp_string (pp
, "goto ");
2730 dump_generic_node (pp
, op0
, spc
, flags
, false);
2734 pp_string (pp
, "__asm__");
2735 if (ASM_VOLATILE_P (node
))
2736 pp_string (pp
, " __volatile__");
2738 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2740 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2742 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2743 if (ASM_CLOBBERS (node
))
2746 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2748 pp_right_paren (pp
);
2751 case CASE_LABEL_EXPR
:
2752 if (CASE_LOW (node
) && CASE_HIGH (node
))
2754 pp_string (pp
, "case ");
2755 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2756 pp_string (pp
, " ... ");
2757 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2759 else if (CASE_LOW (node
))
2761 pp_string (pp
, "case ");
2762 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2765 pp_string (pp
, "default");
2770 pp_string (pp
, "OBJ_TYPE_REF(");
2771 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2773 /* We omit the class type for -fcompare-debug because we may
2774 drop TYPE_BINFO early depending on debug info, and then
2775 virtual_method_call_p would return false, whereas when
2776 TYPE_BINFO is preserved it may still return true and then
2777 we'd print the class type. Compare tree and rtl dumps for
2778 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
2779 for example, at occurrences of OBJ_TYPE_REF. */
2780 if (!(flags
& (TDF_SLIM
| TDF_COMPARE_DEBUG
))
2781 && virtual_method_call_p (node
))
2783 pp_string (pp
, "(");
2784 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2785 pp_string (pp
, ")");
2787 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2789 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2790 pp_right_paren (pp
);
2794 if (SSA_NAME_IDENTIFIER (node
))
2796 if ((flags
& TDF_NOUID
)
2797 && SSA_NAME_VAR (node
)
2798 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
2799 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
2800 else if (! (flags
& TDF_GIMPLE
)
2801 || SSA_NAME_VAR (node
))
2802 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2806 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2807 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2808 pp_string (pp
, "(D)");
2809 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2810 pp_string (pp
, "(ab)");
2813 case WITH_SIZE_EXPR
:
2814 pp_string (pp
, "WITH_SIZE_EXPR <");
2815 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2816 pp_string (pp
, ", ");
2817 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2822 pp_string (pp
, "ASSERT_EXPR <");
2823 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2824 pp_string (pp
, ", ");
2825 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2830 pp_string (pp
, "scev_known");
2833 case SCEV_NOT_KNOWN
:
2834 pp_string (pp
, "scev_not_known");
2837 case POLYNOMIAL_CHREC
:
2839 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2840 pp_string (pp
, ", +, ");
2841 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2842 pp_printf (pp
, "}_%u", CHREC_VARIABLE (node
));
2846 case REALIGN_LOAD_EXPR
:
2847 pp_string (pp
, "REALIGN_LOAD <");
2848 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2849 pp_string (pp
, ", ");
2850 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2851 pp_string (pp
, ", ");
2852 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2857 pp_string (pp
, " VEC_COND_EXPR < ");
2858 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2859 pp_string (pp
, " , ");
2860 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2861 pp_string (pp
, " , ");
2862 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2863 pp_string (pp
, " > ");
2867 pp_string (pp
, " VEC_PERM_EXPR < ");
2868 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2869 pp_string (pp
, " , ");
2870 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2871 pp_string (pp
, " , ");
2872 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2873 pp_string (pp
, " > ");
2877 pp_string (pp
, " DOT_PROD_EXPR < ");
2878 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2879 pp_string (pp
, ", ");
2880 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2881 pp_string (pp
, ", ");
2882 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2883 pp_string (pp
, " > ");
2886 case WIDEN_MULT_PLUS_EXPR
:
2887 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
2888 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2889 pp_string (pp
, ", ");
2890 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2891 pp_string (pp
, ", ");
2892 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2893 pp_string (pp
, " > ");
2896 case WIDEN_MULT_MINUS_EXPR
:
2897 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
2898 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2899 pp_string (pp
, ", ");
2900 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2901 pp_string (pp
, ", ");
2902 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2903 pp_string (pp
, " > ");
2907 pp_string (pp
, "#pragma acc parallel");
2908 goto dump_omp_clauses_body
;
2911 pp_string (pp
, "#pragma acc kernels");
2912 goto dump_omp_clauses_body
;
2915 pp_string (pp
, "#pragma acc data");
2916 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2919 case OACC_HOST_DATA
:
2920 pp_string (pp
, "#pragma acc host_data");
2921 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2925 pp_string (pp
, "#pragma acc declare");
2926 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2930 pp_string (pp
, "#pragma acc update");
2931 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2934 case OACC_ENTER_DATA
:
2935 pp_string (pp
, "#pragma acc enter data");
2936 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2939 case OACC_EXIT_DATA
:
2940 pp_string (pp
, "#pragma acc exit data");
2941 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2945 pp_string (pp
, "#pragma acc cache");
2946 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2950 pp_string (pp
, "#pragma omp parallel");
2951 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2954 dump_omp_clauses_body
:
2955 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2959 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2961 newline_and_indent (pp
, spc
+ 2);
2963 newline_and_indent (pp
, spc
+ 4);
2964 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2965 newline_and_indent (pp
, spc
+ 2);
2966 pp_right_brace (pp
);
2972 pp_string (pp
, "#pragma omp task");
2973 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2977 pp_string (pp
, "#pragma omp for");
2981 pp_string (pp
, "#pragma omp simd");
2984 case OMP_DISTRIBUTE
:
2985 pp_string (pp
, "#pragma omp distribute");
2989 pp_string (pp
, "#pragma omp taskloop");
2993 pp_string (pp
, "#pragma acc loop");
2997 pp_string (pp
, "#pragma omp teams");
2998 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
3001 case OMP_TARGET_DATA
:
3002 pp_string (pp
, "#pragma omp target data");
3003 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
3006 case OMP_TARGET_ENTER_DATA
:
3007 pp_string (pp
, "#pragma omp target enter data");
3008 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3012 case OMP_TARGET_EXIT_DATA
:
3013 pp_string (pp
, "#pragma omp target exit data");
3014 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3019 pp_string (pp
, "#pragma omp target");
3020 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3023 case OMP_TARGET_UPDATE
:
3024 pp_string (pp
, "#pragma omp target update");
3025 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3030 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3031 if (!(flags
& TDF_SLIM
))
3035 if (OMP_FOR_PRE_BODY (node
))
3037 newline_and_indent (pp
, spc
+ 2);
3040 newline_and_indent (pp
, spc
);
3041 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3044 if (OMP_FOR_INIT (node
))
3047 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3050 newline_and_indent (pp
, spc
);
3051 pp_string (pp
, "for (");
3052 dump_generic_node (pp
,
3053 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
3055 pp_string (pp
, "; ");
3056 dump_generic_node (pp
,
3057 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
3059 pp_string (pp
, "; ");
3060 dump_generic_node (pp
,
3061 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3063 pp_right_paren (pp
);
3066 if (OMP_FOR_BODY (node
))
3068 newline_and_indent (pp
, spc
+ 2);
3070 newline_and_indent (pp
, spc
+ 4);
3071 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3073 newline_and_indent (pp
, spc
+ 2);
3074 pp_right_brace (pp
);
3076 if (OMP_FOR_INIT (node
))
3077 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3078 if (OMP_FOR_PRE_BODY (node
))
3081 newline_and_indent (pp
, spc
+ 2);
3082 pp_right_brace (pp
);
3089 pp_string (pp
, "#pragma omp sections");
3090 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3094 pp_string (pp
, "#pragma omp section");
3098 pp_string (pp
, "#pragma omp master");
3102 pp_string (pp
, "#pragma omp taskgroup");
3106 pp_string (pp
, "#pragma omp ordered");
3107 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3111 pp_string (pp
, "#pragma omp critical");
3112 if (OMP_CRITICAL_NAME (node
))
3116 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3118 pp_right_paren (pp
);
3120 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3124 pp_string (pp
, "#pragma omp atomic");
3125 if (OMP_ATOMIC_SEQ_CST (node
))
3126 pp_string (pp
, " seq_cst");
3127 newline_and_indent (pp
, spc
+ 2);
3128 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3132 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3135 case OMP_ATOMIC_READ
:
3136 pp_string (pp
, "#pragma omp atomic read");
3137 if (OMP_ATOMIC_SEQ_CST (node
))
3138 pp_string (pp
, " seq_cst");
3139 newline_and_indent (pp
, spc
+ 2);
3140 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3144 case OMP_ATOMIC_CAPTURE_OLD
:
3145 case OMP_ATOMIC_CAPTURE_NEW
:
3146 pp_string (pp
, "#pragma omp atomic capture");
3147 if (OMP_ATOMIC_SEQ_CST (node
))
3148 pp_string (pp
, " seq_cst");
3149 newline_and_indent (pp
, spc
+ 2);
3150 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3154 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3158 pp_string (pp
, "#pragma omp single");
3159 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3163 dump_omp_clause (pp
, node
, spc
, flags
);
3167 case TRANSACTION_EXPR
:
3168 if (TRANSACTION_EXPR_OUTER (node
))
3169 pp_string (pp
, "__transaction_atomic [[outer]]");
3170 else if (TRANSACTION_EXPR_RELAXED (node
))
3171 pp_string (pp
, "__transaction_relaxed");
3173 pp_string (pp
, "__transaction_atomic");
3174 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3176 newline_and_indent (pp
, spc
);
3178 newline_and_indent (pp
, spc
+ 2);
3179 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3180 spc
+ 2, flags
, false);
3181 newline_and_indent (pp
, spc
);
3182 pp_right_brace (pp
);
3187 case VEC_SERIES_EXPR
:
3188 case VEC_WIDEN_MULT_HI_EXPR
:
3189 case VEC_WIDEN_MULT_LO_EXPR
:
3190 case VEC_WIDEN_MULT_EVEN_EXPR
:
3191 case VEC_WIDEN_MULT_ODD_EXPR
:
3192 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3193 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3195 for (str
= get_tree_code_name (code
); *str
; str
++)
3196 pp_character (pp
, TOUPPER (*str
));
3197 pp_string (pp
, " < ");
3198 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3199 pp_string (pp
, ", ");
3200 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3201 pp_string (pp
, " > ");
3204 case VEC_DUPLICATE_EXPR
:
3206 for (str
= get_tree_code_name (code
); *str
; str
++)
3207 pp_character (pp
, TOUPPER (*str
));
3208 pp_string (pp
, " < ");
3209 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3210 pp_string (pp
, " > ");
3213 case VEC_UNPACK_HI_EXPR
:
3214 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3215 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3216 pp_string (pp
, " > ");
3219 case VEC_UNPACK_LO_EXPR
:
3220 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3221 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3222 pp_string (pp
, " > ");
3225 case VEC_UNPACK_FLOAT_HI_EXPR
:
3226 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3227 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3228 pp_string (pp
, " > ");
3231 case VEC_UNPACK_FLOAT_LO_EXPR
:
3232 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3233 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3234 pp_string (pp
, " > ");
3237 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3238 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
3239 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3240 pp_string (pp
, " > ");
3243 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3244 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
3245 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3246 pp_string (pp
, " > ");
3249 case VEC_PACK_TRUNC_EXPR
:
3250 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3251 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3252 pp_string (pp
, ", ");
3253 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3254 pp_string (pp
, " > ");
3257 case VEC_PACK_SAT_EXPR
:
3258 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3259 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3260 pp_string (pp
, ", ");
3261 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3262 pp_string (pp
, " > ");
3265 case VEC_PACK_FIX_TRUNC_EXPR
:
3266 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3267 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3268 pp_string (pp
, ", ");
3269 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3270 pp_string (pp
, " > ");
3273 case VEC_PACK_FLOAT_EXPR
:
3274 pp_string (pp
, " VEC_PACK_FLOAT_EXPR < ");
3275 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3276 pp_string (pp
, ", ");
3277 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3278 pp_string (pp
, " > ");
3282 dump_block_node (pp
, node
, spc
, flags
);
3285 case DEBUG_BEGIN_STMT
:
3286 pp_string (pp
, "# DEBUG BEGIN STMT");
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 if (!(flags
& TDF_SLIM
))
3385 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3387 pp_string (pp
, "<<< omitted >>>");
3391 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3393 pp_string (pp
, " [value-expr: ");
3394 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3395 pp_right_bracket (pp
);
3402 /* Prints a structure: name, fields, and methods.
3403 FIXME: Still incomplete. */
3406 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
3409 /* Print the name of the structure. */
3410 if (TYPE_NAME (node
))
3413 if (TREE_CODE (node
) == RECORD_TYPE
)
3414 pp_string (pp
, "struct ");
3415 else if ((TREE_CODE (node
) == UNION_TYPE
3416 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3417 pp_string (pp
, "union ");
3419 dump_generic_node (pp
, TYPE_NAME (node
), spc
, 0, false);
3422 /* Print the contents of the structure. */
3428 /* Print the fields of the structure. */
3431 tmp
= TYPE_FIELDS (node
);
3434 /* Avoid to print recursively the structure. */
3435 /* FIXME : Not implemented correctly...,
3436 what about the case when we have a cycle in the contain graph? ...
3437 Maybe this could be solved by looking at the scope in which the
3438 structure was declared. */
3439 if (TREE_TYPE (tmp
) != node
3440 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3441 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3443 print_declaration (pp
, tmp
, spc
+2, flags
);
3446 tmp
= DECL_CHAIN (tmp
);
3450 pp_right_brace (pp
);
3453 /* Return the priority of the operator CODE.
3455 From lowest to highest precedence with either left-to-right (L-R)
3456 or right-to-left (R-L) associativity]:
3459 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3471 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3472 15 [L-R] fn() [] -> .
3474 unary +, - and * have higher precedence than the corresponding binary
3478 op_code_prio (enum tree_code code
)
3495 case TRUTH_ORIF_EXPR
:
3498 case TRUTH_AND_EXPR
:
3499 case TRUTH_ANDIF_EXPR
:
3506 case TRUTH_XOR_EXPR
:
3523 case UNORDERED_EXPR
:
3534 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3535 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3536 case WIDEN_LSHIFT_EXPR
:
3539 case WIDEN_SUM_EXPR
:
3541 case POINTER_PLUS_EXPR
:
3542 case POINTER_DIFF_EXPR
:
3546 case VEC_WIDEN_MULT_HI_EXPR
:
3547 case VEC_WIDEN_MULT_LO_EXPR
:
3548 case WIDEN_MULT_EXPR
:
3550 case WIDEN_MULT_PLUS_EXPR
:
3551 case WIDEN_MULT_MINUS_EXPR
:
3553 case MULT_HIGHPART_EXPR
:
3554 case TRUNC_DIV_EXPR
:
3556 case FLOOR_DIV_EXPR
:
3557 case ROUND_DIV_EXPR
:
3559 case EXACT_DIV_EXPR
:
3560 case TRUNC_MOD_EXPR
:
3562 case FLOOR_MOD_EXPR
:
3563 case ROUND_MOD_EXPR
:
3566 case TRUTH_NOT_EXPR
:
3568 case POSTINCREMENT_EXPR
:
3569 case POSTDECREMENT_EXPR
:
3570 case PREINCREMENT_EXPR
:
3571 case PREDECREMENT_EXPR
:
3577 case FIX_TRUNC_EXPR
:
3583 case ARRAY_RANGE_REF
:
3587 /* Special expressions. */
3593 case VEC_UNPACK_HI_EXPR
:
3594 case VEC_UNPACK_LO_EXPR
:
3595 case VEC_UNPACK_FLOAT_HI_EXPR
:
3596 case VEC_UNPACK_FLOAT_LO_EXPR
:
3597 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3598 case VEC_UNPACK_FIX_TRUNC_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
);