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
) && DECL_ASSEMBLER_NAME_SET_P (node
))
253 pp_tree_identifier (pp
, DECL_ASSEMBLER_NAME (node
));
254 /* For DECL_NAMELESS names look for embedded uids in the
255 names and sanitize them for TDF_NOUID. */
256 else if ((flags
& TDF_NOUID
) && DECL_NAMELESS (node
))
257 dump_fancy_name (pp
, DECL_NAME (node
));
259 pp_tree_identifier (pp
, DECL_NAME (node
));
261 char uid_sep
= (flags
& TDF_GIMPLE
) ? '_' : '.';
262 if ((flags
& TDF_UID
) || DECL_NAME (node
) == NULL_TREE
)
264 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
265 pp_printf (pp
, "L%c%d", uid_sep
, (int) LABEL_DECL_UID (node
));
266 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
268 if (flags
& TDF_NOUID
)
269 pp_string (pp
, "D#xxxx");
271 pp_printf (pp
, "D#%i", DEBUG_TEMP_UID (node
));
275 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
276 if (flags
& TDF_NOUID
)
277 pp_printf (pp
, "%c.xxxx", c
);
279 pp_printf (pp
, "%c%c%u", c
, uid_sep
, DECL_UID (node
));
282 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
284 if (flags
& TDF_NOUID
)
285 pp_printf (pp
, "ptD.xxxx");
287 pp_printf (pp
, "ptD.%u", DECL_PT_UID (node
));
291 /* Like the above, but used for pretty printing function calls. */
294 dump_function_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
296 if (CONVERT_EXPR_P (node
))
297 node
= TREE_OPERAND (node
, 0);
298 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
299 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
301 dump_decl_name (pp
, node
, flags
);
304 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
305 FLAGS are as in dump_generic_node. */
308 dump_function_declaration (pretty_printer
*pp
, tree node
,
309 int spc
, dump_flags_t flags
)
311 bool wrote_arg
= false;
317 /* Print the argument types. */
318 arg
= TYPE_ARG_TYPES (node
);
319 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
327 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
328 arg
= TREE_CHAIN (arg
);
331 /* Drop the trailing void_type_node if we had any previous argument. */
332 if (arg
== void_list_node
&& !wrote_arg
)
333 pp_string (pp
, "void");
334 /* Properly dump vararg function types. */
335 else if (!arg
&& wrote_arg
)
336 pp_string (pp
, ", ...");
337 /* Avoid printing any arg for unprototyped functions. */
342 /* Dump the domain associated with an array. */
345 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, dump_flags_t flags
)
347 pp_left_bracket (pp
);
350 tree min
= TYPE_MIN_VALUE (domain
);
351 tree max
= TYPE_MAX_VALUE (domain
);
354 && integer_zerop (min
)
355 && tree_fits_shwi_p (max
))
356 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
360 dump_generic_node (pp
, min
, spc
, flags
, false);
363 dump_generic_node (pp
, max
, spc
, flags
, false);
367 pp_string (pp
, "<unknown>");
368 pp_right_bracket (pp
);
372 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
373 dump_generic_node. */
376 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
380 switch (OMP_CLAUSE_CODE (clause
))
382 case OMP_CLAUSE_PRIVATE
:
385 case OMP_CLAUSE_SHARED
:
388 case OMP_CLAUSE_FIRSTPRIVATE
:
389 name
= "firstprivate";
391 case OMP_CLAUSE_LASTPRIVATE
:
392 name
= "lastprivate";
394 case OMP_CLAUSE_COPYIN
:
397 case OMP_CLAUSE_COPYPRIVATE
:
398 name
= "copyprivate";
400 case OMP_CLAUSE_UNIFORM
:
403 case OMP_CLAUSE_USE_DEVICE_PTR
:
404 name
= "use_device_ptr";
406 case OMP_CLAUSE_IS_DEVICE_PTR
:
407 name
= "is_device_ptr";
409 case OMP_CLAUSE__LOOPTEMP_
:
412 case OMP_CLAUSE_TO_DECLARE
:
415 case OMP_CLAUSE_LINK
:
419 pp_string (pp
, name
);
421 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
426 case OMP_CLAUSE_REDUCTION
:
427 pp_string (pp
, "reduction(");
428 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
431 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
434 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
440 pp_string (pp
, "if(");
441 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
443 case ERROR_MARK
: break;
444 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
445 case OMP_TASK
: pp_string (pp
, "task:"); break;
446 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
447 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
448 case OMP_TARGET
: pp_string (pp
, "target:"); break;
449 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
450 case OMP_TARGET_ENTER_DATA
:
451 pp_string (pp
, "target enter data:"); break;
452 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
453 default: gcc_unreachable ();
455 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
460 case OMP_CLAUSE_NUM_THREADS
:
461 pp_string (pp
, "num_threads(");
462 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
467 case OMP_CLAUSE__CILK_FOR_COUNT_
:
468 pp_string (pp
, "_Cilk_for_count_(");
469 dump_generic_node (pp
, OMP_CLAUSE_OPERAND (clause
, 0),
474 case OMP_CLAUSE_NOWAIT
:
475 pp_string (pp
, "nowait");
477 case OMP_CLAUSE_ORDERED
:
478 pp_string (pp
, "ordered");
479 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
482 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
488 case OMP_CLAUSE_DEFAULT
:
489 pp_string (pp
, "default(");
490 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
492 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
494 case OMP_CLAUSE_DEFAULT_SHARED
:
495 pp_string (pp
, "shared");
497 case OMP_CLAUSE_DEFAULT_NONE
:
498 pp_string (pp
, "none");
500 case OMP_CLAUSE_DEFAULT_PRIVATE
:
501 pp_string (pp
, "private");
503 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
504 pp_string (pp
, "firstprivate");
506 case OMP_CLAUSE_DEFAULT_PRESENT
:
507 pp_string (pp
, "present");
515 case OMP_CLAUSE_SCHEDULE
:
516 pp_string (pp
, "schedule(");
517 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
518 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
519 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
521 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
522 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
523 pp_string (pp
, "monotonic");
525 pp_string (pp
, "nonmonotonic");
526 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
531 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
532 pp_string (pp
, "simd:");
534 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
536 case OMP_CLAUSE_SCHEDULE_STATIC
:
537 pp_string (pp
, "static");
539 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
540 pp_string (pp
, "dynamic");
542 case OMP_CLAUSE_SCHEDULE_GUIDED
:
543 pp_string (pp
, "guided");
545 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
546 pp_string (pp
, "runtime");
548 case OMP_CLAUSE_SCHEDULE_AUTO
:
549 pp_string (pp
, "auto");
551 case OMP_CLAUSE_SCHEDULE_CILKFOR
:
552 pp_string (pp
, "cilk-for grain");
557 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
560 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
566 case OMP_CLAUSE_UNTIED
:
567 pp_string (pp
, "untied");
570 case OMP_CLAUSE_COLLAPSE
:
571 pp_string (pp
, "collapse(");
572 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
577 case OMP_CLAUSE_FINAL
:
578 pp_string (pp
, "final(");
579 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
584 case OMP_CLAUSE_MERGEABLE
:
585 pp_string (pp
, "mergeable");
588 case OMP_CLAUSE_LINEAR
:
589 pp_string (pp
, "linear(");
590 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
592 case OMP_CLAUSE_LINEAR_DEFAULT
:
594 case OMP_CLAUSE_LINEAR_REF
:
595 pp_string (pp
, "ref(");
597 case OMP_CLAUSE_LINEAR_VAL
:
598 pp_string (pp
, "val(");
600 case OMP_CLAUSE_LINEAR_UVAL
:
601 pp_string (pp
, "uval(");
606 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
608 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
611 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
616 case OMP_CLAUSE_ALIGNED
:
617 pp_string (pp
, "aligned(");
618 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
620 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
623 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
629 case OMP_CLAUSE_DEPEND
:
630 pp_string (pp
, "depend(");
631 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
633 case OMP_CLAUSE_DEPEND_IN
:
634 pp_string (pp
, "in");
636 case OMP_CLAUSE_DEPEND_OUT
:
637 pp_string (pp
, "out");
639 case OMP_CLAUSE_DEPEND_INOUT
:
640 pp_string (pp
, "inout");
642 case OMP_CLAUSE_DEPEND_SOURCE
:
643 pp_string (pp
, "source)");
645 case OMP_CLAUSE_DEPEND_SINK
:
646 pp_string (pp
, "sink:");
647 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
648 if (TREE_CODE (t
) == TREE_LIST
)
650 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
651 if (TREE_PURPOSE (t
) != integer_zero_node
)
653 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
657 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
671 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
677 pp_string (pp
, "map(");
678 switch (OMP_CLAUSE_MAP_KIND (clause
))
681 case GOMP_MAP_POINTER
:
682 pp_string (pp
, "alloc");
685 case GOMP_MAP_TO_PSET
:
686 pp_string (pp
, "to");
689 pp_string (pp
, "from");
691 case GOMP_MAP_TOFROM
:
692 pp_string (pp
, "tofrom");
694 case GOMP_MAP_FORCE_ALLOC
:
695 pp_string (pp
, "force_alloc");
697 case GOMP_MAP_FORCE_TO
:
698 pp_string (pp
, "force_to");
700 case GOMP_MAP_FORCE_FROM
:
701 pp_string (pp
, "force_from");
703 case GOMP_MAP_FORCE_TOFROM
:
704 pp_string (pp
, "force_tofrom");
706 case GOMP_MAP_FORCE_PRESENT
:
707 pp_string (pp
, "force_present");
709 case GOMP_MAP_DELETE
:
710 pp_string (pp
, "delete");
712 case GOMP_MAP_FORCE_DEVICEPTR
:
713 pp_string (pp
, "force_deviceptr");
715 case GOMP_MAP_ALWAYS_TO
:
716 pp_string (pp
, "always,to");
718 case GOMP_MAP_ALWAYS_FROM
:
719 pp_string (pp
, "always,from");
721 case GOMP_MAP_ALWAYS_TOFROM
:
722 pp_string (pp
, "always,tofrom");
724 case GOMP_MAP_RELEASE
:
725 pp_string (pp
, "release");
727 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
728 pp_string (pp
, "firstprivate");
730 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
731 pp_string (pp
, "firstprivate ref");
733 case GOMP_MAP_STRUCT
:
734 pp_string (pp
, "struct");
736 case GOMP_MAP_ALWAYS_POINTER
:
737 pp_string (pp
, "always_pointer");
739 case GOMP_MAP_DEVICE_RESIDENT
:
740 pp_string (pp
, "device_resident");
743 pp_string (pp
, "link");
749 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
752 if (OMP_CLAUSE_SIZE (clause
))
754 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
755 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
757 case GOMP_MAP_POINTER
:
758 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
759 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
760 case GOMP_MAP_ALWAYS_POINTER
:
761 pp_string (pp
, " [pointer assign, bias: ");
763 case GOMP_MAP_TO_PSET
:
764 pp_string (pp
, " [pointer set, len: ");
767 pp_string (pp
, " [len: ");
770 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
772 pp_right_bracket (pp
);
777 case OMP_CLAUSE_FROM
:
778 pp_string (pp
, "from(");
779 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
781 goto print_clause_size
;
784 pp_string (pp
, "to(");
785 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
787 goto print_clause_size
;
789 case OMP_CLAUSE__CACHE_
:
791 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
793 goto print_clause_size
;
795 case OMP_CLAUSE_NUM_TEAMS
:
796 pp_string (pp
, "num_teams(");
797 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
802 case OMP_CLAUSE_THREAD_LIMIT
:
803 pp_string (pp
, "thread_limit(");
804 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
809 case OMP_CLAUSE_DEVICE
:
810 pp_string (pp
, "device(");
811 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
816 case OMP_CLAUSE_DIST_SCHEDULE
:
817 pp_string (pp
, "dist_schedule(static");
818 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
821 dump_generic_node (pp
,
822 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
828 case OMP_CLAUSE_PROC_BIND
:
829 pp_string (pp
, "proc_bind(");
830 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
832 case OMP_CLAUSE_PROC_BIND_MASTER
:
833 pp_string (pp
, "master");
835 case OMP_CLAUSE_PROC_BIND_CLOSE
:
836 pp_string (pp
, "close");
838 case OMP_CLAUSE_PROC_BIND_SPREAD
:
839 pp_string (pp
, "spread");
847 case OMP_CLAUSE_SAFELEN
:
848 pp_string (pp
, "safelen(");
849 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
854 case OMP_CLAUSE_SIMDLEN
:
855 pp_string (pp
, "simdlen(");
856 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
861 case OMP_CLAUSE_PRIORITY
:
862 pp_string (pp
, "priority(");
863 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
868 case OMP_CLAUSE_GRAINSIZE
:
869 pp_string (pp
, "grainsize(");
870 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
875 case OMP_CLAUSE_NUM_TASKS
:
876 pp_string (pp
, "num_tasks(");
877 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
882 case OMP_CLAUSE_HINT
:
883 pp_string (pp
, "hint(");
884 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
889 case OMP_CLAUSE_DEFAULTMAP
:
890 pp_string (pp
, "defaultmap(tofrom:scalar)");
893 case OMP_CLAUSE__SIMDUID_
:
894 pp_string (pp
, "_simduid_(");
895 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
900 case OMP_CLAUSE__SIMT_
:
901 pp_string (pp
, "_simt_");
904 case OMP_CLAUSE_GANG
:
905 pp_string (pp
, "gang");
906 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
908 pp_string (pp
, "(num: ");
909 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
912 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
914 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
918 pp_string (pp
, "static:");
919 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
920 == integer_minus_one_node
)
921 pp_character (pp
, '*');
923 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
926 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
927 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
931 case OMP_CLAUSE_ASYNC
:
932 pp_string (pp
, "async");
933 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
935 pp_character(pp
, '(');
936 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
938 pp_character(pp
, ')');
942 case OMP_CLAUSE_AUTO
:
944 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
947 case OMP_CLAUSE_WAIT
:
948 pp_string (pp
, "wait(");
949 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
951 pp_character(pp
, ')');
954 case OMP_CLAUSE_WORKER
:
955 pp_string (pp
, "worker");
956 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
959 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
965 case OMP_CLAUSE_VECTOR
:
966 pp_string (pp
, "vector");
967 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
970 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
976 case OMP_CLAUSE_NUM_GANGS
:
977 pp_string (pp
, "num_gangs(");
978 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
980 pp_character (pp
, ')');
983 case OMP_CLAUSE_NUM_WORKERS
:
984 pp_string (pp
, "num_workers(");
985 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
987 pp_character (pp
, ')');
990 case OMP_CLAUSE_VECTOR_LENGTH
:
991 pp_string (pp
, "vector_length(");
992 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
994 pp_character (pp
, ')');
997 case OMP_CLAUSE_INBRANCH
:
998 pp_string (pp
, "inbranch");
1000 case OMP_CLAUSE_NOTINBRANCH
:
1001 pp_string (pp
, "notinbranch");
1003 case OMP_CLAUSE_FOR
:
1004 pp_string (pp
, "for");
1006 case OMP_CLAUSE_PARALLEL
:
1007 pp_string (pp
, "parallel");
1009 case OMP_CLAUSE_SECTIONS
:
1010 pp_string (pp
, "sections");
1012 case OMP_CLAUSE_TASKGROUP
:
1013 pp_string (pp
, "taskgroup");
1015 case OMP_CLAUSE_NOGROUP
:
1016 pp_string (pp
, "nogroup");
1018 case OMP_CLAUSE_THREADS
:
1019 pp_string (pp
, "threads");
1021 case OMP_CLAUSE_SIMD
:
1022 pp_string (pp
, "simd");
1024 case OMP_CLAUSE_INDEPENDENT
:
1025 pp_string (pp
, "independent");
1027 case OMP_CLAUSE_TILE
:
1028 pp_string (pp
, "tile(");
1029 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1031 pp_right_paren (pp
);
1034 case OMP_CLAUSE__GRIDDIM_
:
1035 pp_string (pp
, "_griddim_(");
1036 pp_unsigned_wide_integer (pp
, OMP_CLAUSE__GRIDDIM__DIMENSION (clause
));
1038 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__SIZE (clause
), spc
, flags
,
1041 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__GROUP (clause
), spc
, flags
,
1043 pp_right_paren (pp
);
1047 /* Should never happen. */
1048 dump_generic_node (pp
, clause
, spc
, flags
, false);
1054 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1055 dump_generic_node. */
1058 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
1066 dump_omp_clause (pp
, clause
, spc
, flags
);
1067 clause
= OMP_CLAUSE_CHAIN (clause
);
1075 /* Dump location LOC to PP. */
1078 dump_location (pretty_printer
*pp
, location_t loc
)
1080 expanded_location xloc
= expand_location (loc
);
1082 pp_left_bracket (pp
);
1085 pp_string (pp
, xloc
.file
);
1086 pp_string (pp
, ":");
1088 pp_decimal_int (pp
, xloc
.line
);
1090 pp_decimal_int (pp
, xloc
.column
);
1091 pp_string (pp
, "] ");
1095 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1096 dump_generic_node. */
1099 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, dump_flags_t flags
)
1103 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1105 if (flags
& TDF_ADDRESS
)
1106 pp_printf (pp
, "[%p] ", (void *) block
);
1108 if (BLOCK_ABSTRACT (block
))
1109 pp_string (pp
, "[abstract] ");
1111 if (TREE_ASM_WRITTEN (block
))
1112 pp_string (pp
, "[written] ");
1114 if (flags
& TDF_SLIM
)
1117 if (BLOCK_SOURCE_LOCATION (block
))
1118 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1120 newline_and_indent (pp
, spc
+ 2);
1122 if (BLOCK_SUPERCONTEXT (block
))
1124 pp_string (pp
, "SUPERCONTEXT: ");
1125 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1126 flags
| TDF_SLIM
, false);
1127 newline_and_indent (pp
, spc
+ 2);
1130 if (BLOCK_SUBBLOCKS (block
))
1132 pp_string (pp
, "SUBBLOCKS: ");
1133 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1135 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1138 newline_and_indent (pp
, spc
+ 2);
1141 if (BLOCK_CHAIN (block
))
1143 pp_string (pp
, "SIBLINGS: ");
1144 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1146 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1149 newline_and_indent (pp
, spc
+ 2);
1152 if (BLOCK_VARS (block
))
1154 pp_string (pp
, "VARS: ");
1155 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1157 dump_generic_node (pp
, t
, 0, flags
, false);
1160 newline_and_indent (pp
, spc
+ 2);
1163 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1166 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1168 pp_string (pp
, "NONLOCALIZED_VARS: ");
1169 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1171 dump_generic_node (pp
, t
, 0, flags
, false);
1174 newline_and_indent (pp
, spc
+ 2);
1177 if (BLOCK_ABSTRACT_ORIGIN (block
))
1179 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1180 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1181 flags
| TDF_SLIM
, false);
1182 newline_and_indent (pp
, spc
+ 2);
1185 if (BLOCK_FRAGMENT_ORIGIN (block
))
1187 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1188 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1189 flags
| TDF_SLIM
, false);
1190 newline_and_indent (pp
, spc
+ 2);
1193 if (BLOCK_FRAGMENT_CHAIN (block
))
1195 pp_string (pp
, "FRAGMENT_CHAIN: ");
1196 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1198 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1201 newline_and_indent (pp
, spc
+ 2);
1206 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1207 indent. FLAGS specifies details to show in the dump (see TDF_* in
1208 dumpfile.h). If IS_STMT is true, the object printed is considered
1209 to be a statement and it is terminated by ';' if appropriate. */
1212 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
,
1219 enum tree_code code
;
1221 if (node
== NULL_TREE
)
1224 is_expr
= EXPR_P (node
);
1226 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1227 pp_printf (pp
, "<&%p> ", (void *)node
);
1229 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1230 dump_location (pp
, EXPR_LOCATION (node
));
1232 code
= TREE_CODE (node
);
1236 pp_string (pp
, "<<< error >>>");
1239 case IDENTIFIER_NODE
:
1240 pp_tree_identifier (pp
, node
);
1244 while (node
&& node
!= error_mark_node
)
1246 if (TREE_PURPOSE (node
))
1248 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1251 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1252 node
= TREE_CHAIN (node
);
1253 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1262 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1268 if (TREE_VEC_LENGTH (node
) > 0)
1270 size_t len
= TREE_VEC_LENGTH (node
);
1271 for (i
= 0; i
< len
- 1; i
++)
1273 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1278 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1285 case POINTER_BOUNDS_TYPE
:
1288 case FIXED_POINT_TYPE
:
1294 unsigned int quals
= TYPE_QUALS (node
);
1295 enum tree_code_class tclass
;
1297 if (quals
& TYPE_QUAL_ATOMIC
)
1298 pp_string (pp
, "atomic ");
1299 if (quals
& TYPE_QUAL_CONST
)
1300 pp_string (pp
, "const ");
1301 else if (quals
& TYPE_QUAL_VOLATILE
)
1302 pp_string (pp
, "volatile ");
1303 else if (quals
& TYPE_QUAL_RESTRICT
)
1304 pp_string (pp
, "restrict ");
1306 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1308 pp_string (pp
, "<address-space-");
1309 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1310 pp_string (pp
, "> ");
1313 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1315 if (tclass
== tcc_declaration
)
1317 if (DECL_NAME (node
))
1318 dump_decl_name (pp
, node
, flags
);
1320 pp_string (pp
, "<unnamed type decl>");
1322 else if (tclass
== tcc_type
)
1324 if (TYPE_NAME (node
))
1326 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1327 pp_tree_identifier (pp
, TYPE_NAME (node
));
1328 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1329 && DECL_NAME (TYPE_NAME (node
)))
1330 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1332 pp_string (pp
, "<unnamed type>");
1334 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1336 pp_string (pp
, "vector");
1338 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1339 pp_string (pp
, ") ");
1340 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1342 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1344 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1345 pp_string (pp
, (TYPE_UNSIGNED (node
)
1348 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1349 pp_string (pp
, (TYPE_UNSIGNED (node
)
1352 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1353 pp_string (pp
, (TYPE_UNSIGNED (node
)
1356 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1357 pp_string (pp
, (TYPE_UNSIGNED (node
)
1360 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1361 pp_string (pp
, (TYPE_UNSIGNED (node
)
1362 ? "unsigned long long"
1363 : "signed long long"));
1364 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1365 && pow2p_hwi (TYPE_PRECISION (node
)))
1367 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1368 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1369 pp_string (pp
, "_t");
1373 pp_string (pp
, (TYPE_UNSIGNED (node
)
1374 ? "<unnamed-unsigned:"
1375 : "<unnamed-signed:"));
1376 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1380 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1382 pp_string (pp
, "__complex__ ");
1383 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1385 else if (TREE_CODE (node
) == REAL_TYPE
)
1387 pp_string (pp
, "<float:");
1388 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1391 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1393 pp_string (pp
, "<fixed-point-");
1394 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1395 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1398 else if (TREE_CODE (node
) == VOID_TYPE
)
1399 pp_string (pp
, "void");
1401 pp_string (pp
, "<unnamed type>");
1407 case REFERENCE_TYPE
:
1408 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1410 if (TREE_TYPE (node
) == NULL
)
1412 pp_string (pp
, str
);
1413 pp_string (pp
, "<null type>");
1415 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1417 tree fnode
= TREE_TYPE (node
);
1419 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1422 pp_string (pp
, str
);
1423 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1424 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1425 else if (flags
& TDF_NOUID
)
1426 pp_printf (pp
, "<Txxxx>");
1428 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1430 pp_right_paren (pp
);
1431 dump_function_declaration (pp
, fnode
, spc
, flags
);
1435 unsigned int quals
= TYPE_QUALS (node
);
1437 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1439 pp_string (pp
, str
);
1441 if (quals
& TYPE_QUAL_CONST
)
1442 pp_string (pp
, " const");
1443 if (quals
& TYPE_QUAL_VOLATILE
)
1444 pp_string (pp
, " volatile");
1445 if (quals
& TYPE_QUAL_RESTRICT
)
1446 pp_string (pp
, " restrict");
1448 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1450 pp_string (pp
, " <address-space-");
1451 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1455 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1456 pp_string (pp
, " {ref-all}");
1466 if (flags
& TDF_GIMPLE
)
1468 pp_string (pp
, "__MEM <");
1469 dump_generic_node (pp
, TREE_TYPE (node
),
1470 spc
, flags
| TDF_SLIM
, false);
1471 if (TYPE_ALIGN (TREE_TYPE (node
))
1472 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
1474 pp_string (pp
, ", ");
1475 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
1478 pp_string (pp
, " (");
1479 if (TREE_TYPE (TREE_OPERAND (node
, 0))
1480 != TREE_TYPE (TREE_OPERAND (node
, 1)))
1483 dump_generic_node (pp
, TREE_TYPE (TREE_OPERAND (node
, 1)),
1484 spc
, flags
| TDF_SLIM
, false);
1485 pp_right_paren (pp
);
1487 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1488 spc
, flags
| TDF_SLIM
, false);
1489 if (! integer_zerop (TREE_OPERAND (node
, 1)))
1491 pp_string (pp
, " + ");
1492 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1493 spc
, flags
| TDF_SLIM
, false);
1495 pp_right_paren (pp
);
1497 else if (integer_zerop (TREE_OPERAND (node
, 1))
1498 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1499 infer them and MEM_ATTR caching will share MEM_REFs
1500 with differently-typed op0s. */
1501 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1502 /* Released SSA_NAMES have no TREE_TYPE. */
1503 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1504 /* Same pointer types, but ignoring POINTER_TYPE vs.
1506 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1507 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1508 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1509 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1510 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1511 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1512 /* Same value types ignoring qualifiers. */
1513 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1514 == TYPE_MAIN_VARIANT
1515 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1516 && (!(flags
& TDF_ALIAS
)
1517 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1519 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1522 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1526 dump_generic_node (pp
,
1527 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1534 pp_string (pp
, "MEM[");
1536 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1537 dump_generic_node (pp
, ptype
,
1538 spc
, flags
| TDF_SLIM
, false);
1539 pp_right_paren (pp
);
1540 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1542 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1544 pp_string (pp
, " + ");
1545 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1548 if ((flags
& TDF_ALIAS
)
1549 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1551 pp_string (pp
, " clique ");
1552 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1553 pp_string (pp
, " base ");
1554 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1556 pp_right_bracket (pp
);
1561 case TARGET_MEM_REF
:
1563 const char *sep
= "";
1566 pp_string (pp
, "MEM[");
1568 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1570 pp_string (pp
, sep
);
1572 pp_string (pp
, "symbol: ");
1573 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1578 pp_string (pp
, sep
);
1580 pp_string (pp
, "base: ");
1581 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1583 tmp
= TMR_INDEX2 (node
);
1586 pp_string (pp
, sep
);
1588 pp_string (pp
, "base: ");
1589 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1591 tmp
= TMR_INDEX (node
);
1594 pp_string (pp
, sep
);
1596 pp_string (pp
, "index: ");
1597 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1599 tmp
= TMR_STEP (node
);
1602 pp_string (pp
, sep
);
1604 pp_string (pp
, "step: ");
1605 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1607 tmp
= TMR_OFFSET (node
);
1610 pp_string (pp
, sep
);
1612 pp_string (pp
, "offset: ");
1613 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1615 pp_right_bracket (pp
);
1623 /* Print the innermost component type. */
1624 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1625 tmp
= TREE_TYPE (tmp
))
1627 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1629 /* Print the dimensions. */
1630 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1631 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1637 case QUAL_UNION_TYPE
:
1639 unsigned int quals
= TYPE_QUALS (node
);
1641 if (quals
& TYPE_QUAL_ATOMIC
)
1642 pp_string (pp
, "atomic ");
1643 if (quals
& TYPE_QUAL_CONST
)
1644 pp_string (pp
, "const ");
1645 if (quals
& TYPE_QUAL_VOLATILE
)
1646 pp_string (pp
, "volatile ");
1648 /* Print the name of the structure. */
1649 if (TREE_CODE (node
) == RECORD_TYPE
)
1650 pp_string (pp
, "struct ");
1651 else if (TREE_CODE (node
) == UNION_TYPE
)
1652 pp_string (pp
, "union ");
1654 if (TYPE_NAME (node
))
1655 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1656 else if (!(flags
& TDF_SLIM
))
1657 /* FIXME: If we eliminate the 'else' above and attempt
1658 to show the fields for named types, we may get stuck
1659 following a cycle of pointers to structs. The alleged
1660 self-reference check in print_struct_decl will not detect
1661 cycles involving more than one pointer or struct type. */
1662 print_struct_decl (pp
, node
, spc
, flags
);
1671 if (flags
& TDF_GIMPLE
1672 && (POINTER_TYPE_P (TREE_TYPE (node
))
1673 || (TYPE_PRECISION (TREE_TYPE (node
))
1674 < TYPE_PRECISION (integer_type_node
))
1675 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1677 pp_string (pp
, "_Literal (");
1678 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1679 pp_string (pp
, ") ");
1681 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
1682 && ! (flags
& TDF_GIMPLE
))
1684 /* In the case of a pointer, one may want to divide by the
1685 size of the pointed-to type. Unfortunately, this not
1686 straightforward. The C front-end maps expressions
1691 in such a way that the two INTEGER_CST nodes for "5" have
1692 different values but identical types. In the latter
1693 case, the 5 is multiplied by sizeof (int) in c-common.c
1694 (pointer_int_sum) to convert it to a byte address, and
1695 yet the type of the node is left unchanged. Argh. What
1696 is consistent though is that the number value corresponds
1697 to bytes (UNITS) offset.
1699 NB: Neither of the following divisors can be trivially
1700 used to recover the original literal:
1702 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1703 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1704 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1705 pp_string (pp
, "B"); /* pseudo-unit */
1707 else if (tree_fits_shwi_p (node
))
1708 pp_wide_integer (pp
, tree_to_shwi (node
));
1709 else if (tree_fits_uhwi_p (node
))
1710 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1713 wide_int val
= node
;
1715 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1720 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
1721 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
1723 if ((flags
& TDF_GIMPLE
)
1724 && ! (POINTER_TYPE_P (TREE_TYPE (node
))
1725 || (TYPE_PRECISION (TREE_TYPE (node
))
1726 < TYPE_PRECISION (integer_type_node
))
1727 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1729 if (TYPE_UNSIGNED (TREE_TYPE (node
)))
1730 pp_character (pp
, 'u');
1731 if (TYPE_PRECISION (TREE_TYPE (node
))
1732 == TYPE_PRECISION (unsigned_type_node
))
1734 else if (TYPE_PRECISION (TREE_TYPE (node
))
1735 == TYPE_PRECISION (long_unsigned_type_node
))
1736 pp_character (pp
, 'l');
1737 else if (TYPE_PRECISION (TREE_TYPE (node
))
1738 == TYPE_PRECISION (long_long_unsigned_type_node
))
1739 pp_string (pp
, "ll");
1741 if (TREE_OVERFLOW (node
))
1742 pp_string (pp
, "(OVF)");
1746 /* Code copied from print_node. */
1749 if (TREE_OVERFLOW (node
))
1750 pp_string (pp
, " overflow");
1752 d
= TREE_REAL_CST (node
);
1753 if (REAL_VALUE_ISINF (d
))
1754 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1755 else if (REAL_VALUE_ISNAN (d
))
1756 pp_string (pp
, " Nan");
1760 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1761 pp_string (pp
, string
);
1769 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1770 pp_string (pp
, string
);
1775 pp_string (pp
, "__complex__ (");
1776 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
1777 pp_string (pp
, ", ");
1778 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
1779 pp_right_paren (pp
);
1783 pp_string (pp
, "\"");
1784 pretty_print_string (pp
, TREE_STRING_POINTER (node
));
1785 pp_string (pp
, "\"");
1791 pp_string (pp
, "{ ");
1792 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1795 pp_string (pp
, ", ");
1796 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
1799 pp_string (pp
, " }");
1805 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1807 if (TREE_CODE (node
) == METHOD_TYPE
)
1809 if (TYPE_METHOD_BASETYPE (node
))
1810 dump_decl_name (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1813 pp_string (pp
, "<null method basetype>");
1814 pp_colon_colon (pp
);
1816 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1817 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1818 else if (flags
& TDF_NOUID
)
1819 pp_printf (pp
, "<Txxxx>");
1821 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1822 dump_function_declaration (pp
, node
, spc
, flags
);
1827 dump_decl_name (pp
, node
, flags
);
1831 if (DECL_NAME (node
))
1832 dump_decl_name (pp
, node
, flags
);
1833 else if (LABEL_DECL_UID (node
) != -1)
1835 if (flags
& TDF_GIMPLE
)
1836 pp_printf (pp
, "L%d", (int) LABEL_DECL_UID (node
));
1838 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
1842 if (flags
& TDF_NOUID
)
1843 pp_string (pp
, "<D.xxxx>");
1846 if (flags
& TDF_GIMPLE
)
1847 pp_printf (pp
, "<D%u>", DECL_UID (node
));
1849 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
1855 if (DECL_IS_BUILTIN (node
))
1857 /* Don't print the declaration of built-in types. */
1860 if (DECL_NAME (node
))
1861 dump_decl_name (pp
, node
, flags
);
1862 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1864 pp_string (pp
, (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1865 ? "union" : "struct "));
1866 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1869 pp_string (pp
, "<anon>");
1875 case DEBUG_EXPR_DECL
:
1876 case NAMESPACE_DECL
:
1878 dump_decl_name (pp
, node
, flags
);
1882 pp_string (pp
, "<retval>");
1886 op0
= TREE_OPERAND (node
, 0);
1889 && (TREE_CODE (op0
) == INDIRECT_REF
1890 || (TREE_CODE (op0
) == MEM_REF
1891 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1892 && integer_zerop (TREE_OPERAND (op0
, 1))
1893 /* Dump the types of INTEGER_CSTs explicitly, for we
1894 can't infer them and MEM_ATTR caching will share
1895 MEM_REFs with differently-typed op0s. */
1896 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1897 /* Released SSA_NAMES have no TREE_TYPE. */
1898 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1899 /* Same pointer types, but ignoring POINTER_TYPE vs.
1901 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1902 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1903 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1904 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1905 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1906 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1907 /* Same value types ignoring qualifiers. */
1908 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1909 == TYPE_MAIN_VARIANT
1910 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
1911 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
1913 op0
= TREE_OPERAND (op0
, 0);
1916 if (op_prio (op0
) < op_prio (node
))
1918 dump_generic_node (pp
, op0
, spc
, flags
, false);
1919 if (op_prio (op0
) < op_prio (node
))
1920 pp_right_paren (pp
);
1921 pp_string (pp
, str
);
1922 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1923 op0
= component_ref_field_offset (node
);
1924 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1926 pp_string (pp
, "{off: ");
1927 dump_generic_node (pp
, op0
, spc
, flags
, false);
1928 pp_right_brace (pp
);
1933 pp_string (pp
, "BIT_FIELD_REF <");
1934 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1935 pp_string (pp
, ", ");
1936 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1937 pp_string (pp
, ", ");
1938 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1942 case BIT_INSERT_EXPR
:
1943 pp_string (pp
, "BIT_INSERT_EXPR <");
1944 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1945 pp_string (pp
, ", ");
1946 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1947 pp_string (pp
, ", ");
1948 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1949 pp_string (pp
, " (");
1950 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
1952 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
1954 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
1956 pp_string (pp
, " bits)>");
1960 case ARRAY_RANGE_REF
:
1961 op0
= TREE_OPERAND (node
, 0);
1962 if (op_prio (op0
) < op_prio (node
))
1964 dump_generic_node (pp
, op0
, spc
, flags
, false);
1965 if (op_prio (op0
) < op_prio (node
))
1966 pp_right_paren (pp
);
1967 pp_left_bracket (pp
);
1968 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1969 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1970 pp_string (pp
, " ...");
1971 pp_right_bracket (pp
);
1973 op0
= array_ref_low_bound (node
);
1974 op1
= array_ref_element_size (node
);
1976 if (!integer_zerop (op0
)
1977 || TREE_OPERAND (node
, 2)
1978 || TREE_OPERAND (node
, 3))
1980 pp_string (pp
, "{lb: ");
1981 dump_generic_node (pp
, op0
, spc
, flags
, false);
1982 pp_string (pp
, " sz: ");
1983 dump_generic_node (pp
, op1
, spc
, flags
, false);
1984 pp_right_brace (pp
);
1990 unsigned HOST_WIDE_INT ix
;
1992 bool is_struct_init
= false;
1993 bool is_array_init
= false;
1996 if (TREE_CLOBBER_P (node
))
1997 pp_string (pp
, "CLOBBER");
1998 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1999 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
2000 is_struct_init
= true;
2001 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
2002 && TYPE_DOMAIN (TREE_TYPE (node
))
2003 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
2004 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
2007 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
2008 is_array_init
= true;
2009 curidx
= wi::to_widest (minv
);
2011 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
2018 dump_generic_node (pp
, field
, spc
, flags
, false);
2021 else if (is_array_init
2022 && (TREE_CODE (field
) != INTEGER_CST
2023 || curidx
!= wi::to_widest (field
)))
2025 pp_left_bracket (pp
);
2026 if (TREE_CODE (field
) == RANGE_EXPR
)
2028 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
2030 pp_string (pp
, " ... ");
2031 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
2033 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
2034 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
2037 dump_generic_node (pp
, field
, spc
, flags
, false);
2038 if (TREE_CODE (field
) == INTEGER_CST
)
2039 curidx
= wi::to_widest (field
);
2040 pp_string (pp
, "]=");
2045 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
2046 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
2047 val
= TREE_OPERAND (val
, 0);
2048 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
2049 dump_decl_name (pp
, val
, flags
);
2051 dump_generic_node (pp
, val
, spc
, flags
, false);
2052 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2058 pp_right_brace (pp
);
2065 if (flags
& TDF_SLIM
)
2067 pp_string (pp
, "<COMPOUND_EXPR>");
2071 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2072 spc
, flags
, !(flags
& TDF_SLIM
));
2073 if (flags
& TDF_SLIM
)
2074 newline_and_indent (pp
, spc
);
2081 for (tp
= &TREE_OPERAND (node
, 1);
2082 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2083 tp
= &TREE_OPERAND (*tp
, 1))
2085 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2086 spc
, flags
, !(flags
& TDF_SLIM
));
2087 if (flags
& TDF_SLIM
)
2088 newline_and_indent (pp
, spc
);
2096 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2100 case STATEMENT_LIST
:
2102 tree_stmt_iterator si
;
2105 if (flags
& TDF_SLIM
)
2107 pp_string (pp
, "<STATEMENT_LIST>");
2111 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2114 newline_and_indent (pp
, spc
);
2117 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2124 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2129 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2134 pp_string (pp
, "TARGET_EXPR <");
2135 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2138 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2143 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2148 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2150 pp_string (pp
, "if (");
2151 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2152 pp_right_paren (pp
);
2153 /* The lowered cond_exprs should always be printed in full. */
2154 if (COND_EXPR_THEN (node
)
2155 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2156 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2157 && COND_EXPR_ELSE (node
)
2158 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2159 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2162 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2164 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2166 pp_string (pp
, " else ");
2167 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2171 else if (!(flags
& TDF_SLIM
))
2173 /* Output COND_EXPR_THEN. */
2174 if (COND_EXPR_THEN (node
))
2176 newline_and_indent (pp
, spc
+2);
2178 newline_and_indent (pp
, spc
+4);
2179 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2181 newline_and_indent (pp
, spc
+2);
2182 pp_right_brace (pp
);
2185 /* Output COND_EXPR_ELSE. */
2186 if (COND_EXPR_ELSE (node
)
2187 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2189 newline_and_indent (pp
, spc
);
2190 pp_string (pp
, "else");
2191 newline_and_indent (pp
, spc
+2);
2193 newline_and_indent (pp
, spc
+4);
2194 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2196 newline_and_indent (pp
, spc
+2);
2197 pp_right_brace (pp
);
2204 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2208 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2212 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2218 if (!(flags
& TDF_SLIM
))
2220 if (BIND_EXPR_VARS (node
))
2224 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2226 print_declaration (pp
, op0
, spc
+2, flags
);
2231 newline_and_indent (pp
, spc
+2);
2232 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2233 newline_and_indent (pp
, spc
);
2234 pp_right_brace (pp
);
2240 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2241 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2243 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2245 /* Print parameters. */
2250 call_expr_arg_iterator iter
;
2251 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2253 dump_generic_node (pp
, arg
, spc
, flags
, false);
2254 if (more_call_expr_args_p (&iter
))
2261 if (CALL_EXPR_VA_ARG_PACK (node
))
2263 if (call_expr_nargs (node
) > 0)
2268 pp_string (pp
, "__builtin_va_arg_pack ()");
2270 pp_right_paren (pp
);
2272 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2275 pp_string (pp
, " [static-chain: ");
2276 dump_generic_node (pp
, op1
, spc
, flags
, false);
2277 pp_right_bracket (pp
);
2280 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2281 pp_string (pp
, " [return slot optimization]");
2282 if (CALL_EXPR_TAILCALL (node
))
2283 pp_string (pp
, " [tail call]");
2286 case WITH_CLEANUP_EXPR
:
2290 case CLEANUP_POINT_EXPR
:
2291 pp_string (pp
, "<<cleanup_point ");
2292 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2293 pp_string (pp
, ">>");
2296 case PLACEHOLDER_EXPR
:
2297 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2298 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2302 /* Binary arithmetic and logic expressions. */
2303 case WIDEN_SUM_EXPR
:
2304 case WIDEN_MULT_EXPR
:
2306 case MULT_HIGHPART_EXPR
:
2308 case POINTER_PLUS_EXPR
:
2310 case TRUNC_DIV_EXPR
:
2312 case FLOOR_DIV_EXPR
:
2313 case ROUND_DIV_EXPR
:
2314 case TRUNC_MOD_EXPR
:
2316 case FLOOR_MOD_EXPR
:
2317 case ROUND_MOD_EXPR
:
2319 case EXACT_DIV_EXPR
:
2324 case WIDEN_LSHIFT_EXPR
:
2328 case TRUTH_ANDIF_EXPR
:
2329 case TRUTH_ORIF_EXPR
:
2330 case TRUTH_AND_EXPR
:
2332 case TRUTH_XOR_EXPR
:
2346 case UNORDERED_EXPR
:
2348 const char *op
= op_symbol (node
);
2349 op0
= TREE_OPERAND (node
, 0);
2350 op1
= TREE_OPERAND (node
, 1);
2352 /* When the operands are expressions with less priority,
2353 keep semantics of the tree representation. */
2354 if (op_prio (op0
) <= op_prio (node
))
2357 dump_generic_node (pp
, op0
, spc
, flags
, false);
2358 pp_right_paren (pp
);
2361 dump_generic_node (pp
, op0
, spc
, flags
, false);
2367 /* When the operands are expressions with less priority,
2368 keep semantics of the tree representation. */
2369 if (op_prio (op1
) <= op_prio (node
))
2372 dump_generic_node (pp
, op1
, spc
, flags
, false);
2373 pp_right_paren (pp
);
2376 dump_generic_node (pp
, op1
, spc
, flags
, false);
2380 /* Unary arithmetic and logic expressions. */
2383 case TRUTH_NOT_EXPR
:
2385 case PREDECREMENT_EXPR
:
2386 case PREINCREMENT_EXPR
:
2388 if (TREE_CODE (node
) == ADDR_EXPR
2389 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2390 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2391 ; /* Do not output '&' for strings and function pointers. */
2393 pp_string (pp
, op_symbol (node
));
2395 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2398 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2399 pp_right_paren (pp
);
2402 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2405 case POSTDECREMENT_EXPR
:
2406 case POSTINCREMENT_EXPR
:
2407 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2410 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2411 pp_right_paren (pp
);
2414 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2415 pp_string (pp
, op_symbol (node
));
2419 pp_string (pp
, "MIN_EXPR <");
2420 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2421 pp_string (pp
, ", ");
2422 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2427 pp_string (pp
, "MAX_EXPR <");
2428 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2429 pp_string (pp
, ", ");
2430 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2435 pp_string (pp
, "ABS_EXPR <");
2436 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2444 case ADDR_SPACE_CONVERT_EXPR
:
2445 case FIXED_CONVERT_EXPR
:
2446 case FIX_TRUNC_EXPR
:
2449 type
= TREE_TYPE (node
);
2450 op0
= TREE_OPERAND (node
, 0);
2451 if (type
!= TREE_TYPE (op0
))
2454 dump_generic_node (pp
, type
, spc
, flags
, false);
2455 pp_string (pp
, ") ");
2457 if (op_prio (op0
) < op_prio (node
))
2459 dump_generic_node (pp
, op0
, spc
, flags
, false);
2460 if (op_prio (op0
) < op_prio (node
))
2461 pp_right_paren (pp
);
2464 case VIEW_CONVERT_EXPR
:
2465 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2466 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2467 pp_string (pp
, ">(");
2468 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2469 pp_right_paren (pp
);
2473 pp_string (pp
, "((");
2474 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2475 pp_string (pp
, "))");
2478 case NON_LVALUE_EXPR
:
2479 pp_string (pp
, "NON_LVALUE_EXPR <");
2480 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2485 pp_string (pp
, "SAVE_EXPR <");
2486 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2491 pp_string (pp
, "COMPLEX_EXPR <");
2492 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2493 pp_string (pp
, ", ");
2494 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2499 pp_string (pp
, "CONJ_EXPR <");
2500 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2505 if (flags
& TDF_GIMPLE
)
2507 pp_string (pp
, "__real ");
2508 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2512 pp_string (pp
, "REALPART_EXPR <");
2513 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2519 if (flags
& TDF_GIMPLE
)
2521 pp_string (pp
, "__imag ");
2522 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2526 pp_string (pp
, "IMAGPART_EXPR <");
2527 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2533 pp_string (pp
, "VA_ARG_EXPR <");
2534 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2538 case TRY_FINALLY_EXPR
:
2539 case TRY_CATCH_EXPR
:
2540 pp_string (pp
, "try");
2541 newline_and_indent (pp
, spc
+2);
2543 newline_and_indent (pp
, spc
+4);
2544 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2545 newline_and_indent (pp
, spc
+2);
2546 pp_right_brace (pp
);
2547 newline_and_indent (pp
, spc
);
2549 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2550 newline_and_indent (pp
, spc
+2);
2552 newline_and_indent (pp
, spc
+4);
2553 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2554 newline_and_indent (pp
, spc
+2);
2555 pp_right_brace (pp
);
2560 pp_string (pp
, "catch (");
2561 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2562 pp_right_paren (pp
);
2563 newline_and_indent (pp
, spc
+2);
2565 newline_and_indent (pp
, spc
+4);
2566 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2567 newline_and_indent (pp
, spc
+2);
2568 pp_right_brace (pp
);
2572 case EH_FILTER_EXPR
:
2573 pp_string (pp
, "<<<eh_filter (");
2574 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2575 pp_string (pp
, ")>>>");
2576 newline_and_indent (pp
, spc
+2);
2578 newline_and_indent (pp
, spc
+4);
2579 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2580 newline_and_indent (pp
, spc
+2);
2581 pp_right_brace (pp
);
2586 op0
= TREE_OPERAND (node
, 0);
2587 /* If this is for break or continue, don't bother printing it. */
2588 if (DECL_NAME (op0
))
2590 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2591 if (strcmp (name
, "break") == 0
2592 || strcmp (name
, "continue") == 0)
2595 dump_generic_node (pp
, op0
, spc
, flags
, false);
2597 if (DECL_NONLOCAL (op0
))
2598 pp_string (pp
, " [non-local]");
2602 pp_string (pp
, "while (1)");
2603 if (!(flags
& TDF_SLIM
))
2605 newline_and_indent (pp
, spc
+2);
2607 newline_and_indent (pp
, spc
+4);
2608 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2609 newline_and_indent (pp
, spc
+2);
2610 pp_right_brace (pp
);
2616 pp_string (pp
, "// predicted ");
2617 if (PREDICT_EXPR_OUTCOME (node
))
2618 pp_string (pp
, "likely by ");
2620 pp_string (pp
, "unlikely by ");
2621 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2622 pp_string (pp
, " predictor.");
2626 pp_string (pp
, "ANNOTATE_EXPR <");
2627 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2628 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2630 case annot_expr_ivdep_kind
:
2631 pp_string (pp
, ", ivdep");
2633 case annot_expr_no_vector_kind
:
2634 pp_string (pp
, ", no-vector");
2636 case annot_expr_vector_kind
:
2637 pp_string (pp
, ", vector");
2646 pp_string (pp
, "return");
2647 op0
= TREE_OPERAND (node
, 0);
2651 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2652 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2655 dump_generic_node (pp
, op0
, spc
, flags
, false);
2660 pp_string (pp
, "if (");
2661 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2662 pp_string (pp
, ") break");
2666 pp_string (pp
, "switch (");
2667 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2668 pp_right_paren (pp
);
2669 if (!(flags
& TDF_SLIM
))
2671 newline_and_indent (pp
, spc
+2);
2673 if (SWITCH_BODY (node
))
2675 newline_and_indent (pp
, spc
+4);
2676 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2681 tree vec
= SWITCH_LABELS (node
);
2682 size_t i
, n
= TREE_VEC_LENGTH (vec
);
2683 for (i
= 0; i
< n
; ++i
)
2685 tree elt
= TREE_VEC_ELT (vec
, i
);
2686 newline_and_indent (pp
, spc
+4);
2689 dump_generic_node (pp
, elt
, spc
+4, flags
, false);
2690 pp_string (pp
, " goto ");
2691 dump_generic_node (pp
, CASE_LABEL (elt
), spc
+4,
2696 pp_string (pp
, "case ???: goto ???;");
2699 newline_and_indent (pp
, spc
+2);
2700 pp_right_brace (pp
);
2706 op0
= GOTO_DESTINATION (node
);
2707 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2709 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2710 if (strcmp (name
, "break") == 0
2711 || strcmp (name
, "continue") == 0)
2713 pp_string (pp
, name
);
2717 pp_string (pp
, "goto ");
2718 dump_generic_node (pp
, op0
, spc
, flags
, false);
2722 pp_string (pp
, "__asm__");
2723 if (ASM_VOLATILE_P (node
))
2724 pp_string (pp
, " __volatile__");
2726 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2728 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2730 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2731 if (ASM_CLOBBERS (node
))
2734 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2736 pp_right_paren (pp
);
2739 case CASE_LABEL_EXPR
:
2740 if (CASE_LOW (node
) && CASE_HIGH (node
))
2742 pp_string (pp
, "case ");
2743 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2744 pp_string (pp
, " ... ");
2745 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2747 else if (CASE_LOW (node
))
2749 pp_string (pp
, "case ");
2750 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2753 pp_string (pp
, "default");
2758 pp_string (pp
, "OBJ_TYPE_REF(");
2759 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2761 if (!(flags
& TDF_SLIM
) && virtual_method_call_p (node
))
2763 pp_string (pp
, "(");
2764 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2765 pp_string (pp
, ")");
2767 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2769 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2770 pp_right_paren (pp
);
2774 if (SSA_NAME_IDENTIFIER (node
))
2776 if ((flags
& TDF_NOUID
)
2777 && SSA_NAME_VAR (node
)
2778 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
2779 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
2780 else if (! (flags
& TDF_GIMPLE
)
2781 || SSA_NAME_VAR (node
))
2782 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2786 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2787 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2788 pp_string (pp
, "(D)");
2789 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2790 pp_string (pp
, "(ab)");
2793 case WITH_SIZE_EXPR
:
2794 pp_string (pp
, "WITH_SIZE_EXPR <");
2795 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2796 pp_string (pp
, ", ");
2797 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2802 pp_string (pp
, "ASSERT_EXPR <");
2803 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2804 pp_string (pp
, ", ");
2805 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2810 pp_string (pp
, "scev_known");
2813 case SCEV_NOT_KNOWN
:
2814 pp_string (pp
, "scev_not_known");
2817 case POLYNOMIAL_CHREC
:
2819 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2820 pp_string (pp
, ", +, ");
2821 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2822 pp_string (pp
, "}_");
2823 dump_generic_node (pp
, CHREC_VAR (node
), spc
, flags
, false);
2827 case REALIGN_LOAD_EXPR
:
2828 pp_string (pp
, "REALIGN_LOAD <");
2829 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2830 pp_string (pp
, ", ");
2831 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2832 pp_string (pp
, ", ");
2833 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2838 pp_string (pp
, " VEC_COND_EXPR < ");
2839 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2840 pp_string (pp
, " , ");
2841 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2842 pp_string (pp
, " , ");
2843 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2844 pp_string (pp
, " > ");
2848 pp_string (pp
, " VEC_PERM_EXPR < ");
2849 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2850 pp_string (pp
, " , ");
2851 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2852 pp_string (pp
, " , ");
2853 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2854 pp_string (pp
, " > ");
2858 pp_string (pp
, " DOT_PROD_EXPR < ");
2859 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2860 pp_string (pp
, ", ");
2861 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2862 pp_string (pp
, ", ");
2863 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2864 pp_string (pp
, " > ");
2867 case WIDEN_MULT_PLUS_EXPR
:
2868 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
2869 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2870 pp_string (pp
, ", ");
2871 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2872 pp_string (pp
, ", ");
2873 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2874 pp_string (pp
, " > ");
2877 case WIDEN_MULT_MINUS_EXPR
:
2878 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
2879 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2880 pp_string (pp
, ", ");
2881 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2882 pp_string (pp
, ", ");
2883 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2884 pp_string (pp
, " > ");
2888 pp_string (pp
, " FMA_EXPR < ");
2889 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2890 pp_string (pp
, ", ");
2891 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2892 pp_string (pp
, ", ");
2893 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2894 pp_string (pp
, " > ");
2898 pp_string (pp
, "#pragma acc parallel");
2899 goto dump_omp_clauses_body
;
2902 pp_string (pp
, "#pragma acc kernels");
2903 goto dump_omp_clauses_body
;
2906 pp_string (pp
, "#pragma acc data");
2907 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2910 case OACC_HOST_DATA
:
2911 pp_string (pp
, "#pragma acc host_data");
2912 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2916 pp_string (pp
, "#pragma acc declare");
2917 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2921 pp_string (pp
, "#pragma acc update");
2922 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2925 case OACC_ENTER_DATA
:
2926 pp_string (pp
, "#pragma acc enter data");
2927 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2930 case OACC_EXIT_DATA
:
2931 pp_string (pp
, "#pragma acc exit data");
2932 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2936 pp_string (pp
, "#pragma acc cache");
2937 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2941 pp_string (pp
, "#pragma omp parallel");
2942 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2945 dump_omp_clauses_body
:
2946 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2950 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2952 newline_and_indent (pp
, spc
+ 2);
2954 newline_and_indent (pp
, spc
+ 4);
2955 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2956 newline_and_indent (pp
, spc
+ 2);
2957 pp_right_brace (pp
);
2963 pp_string (pp
, "#pragma omp task");
2964 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2968 pp_string (pp
, "#pragma omp for");
2972 pp_string (pp
, "#pragma omp simd");
2976 pp_string (pp
, "#pragma simd");
2980 /* This label points one line after dumping the clauses.
2981 For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2982 parameters are printed out. */
2983 goto dump_omp_loop_cilk_for
;
2985 case OMP_DISTRIBUTE
:
2986 pp_string (pp
, "#pragma omp distribute");
2990 pp_string (pp
, "#pragma omp taskloop");
2994 pp_string (pp
, "#pragma acc loop");
2998 pp_string (pp
, "#pragma omp teams");
2999 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
3002 case OMP_TARGET_DATA
:
3003 pp_string (pp
, "#pragma omp target data");
3004 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
3007 case OMP_TARGET_ENTER_DATA
:
3008 pp_string (pp
, "#pragma omp target enter data");
3009 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3013 case OMP_TARGET_EXIT_DATA
:
3014 pp_string (pp
, "#pragma omp target exit data");
3015 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3020 pp_string (pp
, "#pragma omp target");
3021 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3024 case OMP_TARGET_UPDATE
:
3025 pp_string (pp
, "#pragma omp target update");
3026 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3031 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3033 dump_omp_loop_cilk_for
:
3034 if (!(flags
& TDF_SLIM
))
3038 if (OMP_FOR_PRE_BODY (node
))
3040 if (TREE_CODE (node
) == CILK_FOR
)
3041 pp_string (pp
, " ");
3043 newline_and_indent (pp
, spc
+ 2);
3046 newline_and_indent (pp
, spc
);
3047 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3050 if (OMP_FOR_INIT (node
))
3053 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3056 if (TREE_CODE (node
) != CILK_FOR
|| OMP_FOR_PRE_BODY (node
))
3057 newline_and_indent (pp
, spc
);
3058 if (TREE_CODE (node
) == CILK_FOR
)
3059 pp_string (pp
, "_Cilk_for (");
3061 pp_string (pp
, "for (");
3062 dump_generic_node (pp
,
3063 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
3065 pp_string (pp
, "; ");
3066 dump_generic_node (pp
,
3067 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
3069 pp_string (pp
, "; ");
3070 dump_generic_node (pp
,
3071 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3073 pp_right_paren (pp
);
3075 if (TREE_CODE (node
) == CILK_FOR
)
3076 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3078 if (OMP_FOR_BODY (node
))
3080 newline_and_indent (pp
, spc
+ 2);
3082 newline_and_indent (pp
, spc
+ 4);
3083 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3085 newline_and_indent (pp
, spc
+ 2);
3086 pp_right_brace (pp
);
3088 if (OMP_FOR_INIT (node
))
3089 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3090 if (OMP_FOR_PRE_BODY (node
))
3093 newline_and_indent (pp
, spc
+ 2);
3094 pp_right_brace (pp
);
3101 pp_string (pp
, "#pragma omp sections");
3102 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3106 pp_string (pp
, "#pragma omp section");
3110 pp_string (pp
, "#pragma omp master");
3114 pp_string (pp
, "#pragma omp taskgroup");
3118 pp_string (pp
, "#pragma omp ordered");
3119 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3123 pp_string (pp
, "#pragma omp critical");
3124 if (OMP_CRITICAL_NAME (node
))
3128 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3130 pp_right_paren (pp
);
3132 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3136 pp_string (pp
, "#pragma omp atomic");
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 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3147 case OMP_ATOMIC_READ
:
3148 pp_string (pp
, "#pragma omp atomic read");
3149 if (OMP_ATOMIC_SEQ_CST (node
))
3150 pp_string (pp
, " seq_cst");
3151 newline_and_indent (pp
, spc
+ 2);
3152 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3156 case OMP_ATOMIC_CAPTURE_OLD
:
3157 case OMP_ATOMIC_CAPTURE_NEW
:
3158 pp_string (pp
, "#pragma omp atomic capture");
3159 if (OMP_ATOMIC_SEQ_CST (node
))
3160 pp_string (pp
, " seq_cst");
3161 newline_and_indent (pp
, spc
+ 2);
3162 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3166 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3170 pp_string (pp
, "#pragma omp single");
3171 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3175 dump_omp_clause (pp
, node
, spc
, flags
);
3179 case TRANSACTION_EXPR
:
3180 if (TRANSACTION_EXPR_OUTER (node
))
3181 pp_string (pp
, "__transaction_atomic [[outer]]");
3182 else if (TRANSACTION_EXPR_RELAXED (node
))
3183 pp_string (pp
, "__transaction_relaxed");
3185 pp_string (pp
, "__transaction_atomic");
3186 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3188 newline_and_indent (pp
, spc
);
3190 newline_and_indent (pp
, spc
+ 2);
3191 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3192 spc
+ 2, flags
, false);
3193 newline_and_indent (pp
, spc
);
3194 pp_right_brace (pp
);
3199 case REDUC_MAX_EXPR
:
3200 pp_string (pp
, " REDUC_MAX_EXPR < ");
3201 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3202 pp_string (pp
, " > ");
3205 case REDUC_MIN_EXPR
:
3206 pp_string (pp
, " REDUC_MIN_EXPR < ");
3207 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3208 pp_string (pp
, " > ");
3211 case REDUC_PLUS_EXPR
:
3212 pp_string (pp
, " REDUC_PLUS_EXPR < ");
3213 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3214 pp_string (pp
, " > ");
3217 case VEC_WIDEN_MULT_HI_EXPR
:
3218 case VEC_WIDEN_MULT_LO_EXPR
:
3219 case VEC_WIDEN_MULT_EVEN_EXPR
:
3220 case VEC_WIDEN_MULT_ODD_EXPR
:
3221 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3222 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3224 for (str
= get_tree_code_name (code
); *str
; str
++)
3225 pp_character (pp
, TOUPPER (*str
));
3226 pp_string (pp
, " < ");
3227 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3228 pp_string (pp
, ", ");
3229 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3230 pp_string (pp
, " > ");
3233 case VEC_UNPACK_HI_EXPR
:
3234 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3235 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3236 pp_string (pp
, " > ");
3239 case VEC_UNPACK_LO_EXPR
:
3240 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3241 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3242 pp_string (pp
, " > ");
3245 case VEC_UNPACK_FLOAT_HI_EXPR
:
3246 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3247 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3248 pp_string (pp
, " > ");
3251 case VEC_UNPACK_FLOAT_LO_EXPR
:
3252 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3253 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3254 pp_string (pp
, " > ");
3257 case VEC_PACK_TRUNC_EXPR
:
3258 pp_string (pp
, " VEC_PACK_TRUNC_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_SAT_EXPR
:
3266 pp_string (pp
, " VEC_PACK_SAT_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_FIX_TRUNC_EXPR
:
3274 pp_string (pp
, " VEC_PACK_FIX_TRUNC_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 CILK_SPAWN_STMT
:
3286 pp_string (pp
, "_Cilk_spawn ");
3287 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3290 case CILK_SYNC_STMT
:
3291 pp_string (pp
, "_Cilk_sync");
3298 if (is_stmt
&& is_expr
)
3304 /* Print the declaration of a variable. */
3307 print_declaration (pretty_printer
*pp
, tree t
, int spc
, dump_flags_t flags
)
3311 if (TREE_CODE(t
) == NAMELIST_DECL
)
3313 pp_string(pp
, "namelist ");
3314 dump_decl_name (pp
, t
, flags
);
3319 if (TREE_CODE (t
) == TYPE_DECL
)
3320 pp_string (pp
, "typedef ");
3322 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3323 pp_string (pp
, "register ");
3325 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3326 pp_string (pp
, "extern ");
3327 else if (TREE_STATIC (t
))
3328 pp_string (pp
, "static ");
3330 /* Print the type and name. */
3331 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3335 /* Print array's type. */
3336 tmp
= TREE_TYPE (t
);
3337 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3338 tmp
= TREE_TYPE (tmp
);
3339 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3341 /* Print variable's name. */
3343 dump_generic_node (pp
, t
, spc
, flags
, false);
3345 /* Print the dimensions. */
3346 tmp
= TREE_TYPE (t
);
3347 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3349 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3350 tmp
= TREE_TYPE (tmp
);
3353 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3355 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3357 dump_decl_name (pp
, t
, flags
);
3358 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3362 /* Print type declaration. */
3363 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3365 /* Print variable's name. */
3367 dump_generic_node (pp
, t
, spc
, flags
, false);
3370 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
3372 pp_string (pp
, " __asm__ ");
3374 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3375 pp_right_paren (pp
);
3378 /* The initial value of a function serves to determine whether the function
3379 is declared or defined. So the following does not apply to function
3381 if (TREE_CODE (t
) != FUNCTION_DECL
)
3383 /* Print the initial value. */
3384 if (DECL_INITIAL (t
))
3389 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3393 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3395 pp_string (pp
, " [value-expr: ");
3396 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3397 pp_right_bracket (pp
);
3404 /* Prints a structure: name, fields, and methods.
3405 FIXME: Still incomplete. */
3408 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
3411 /* Print the name of the structure. */
3412 if (TYPE_NAME (node
))
3415 if (TREE_CODE (node
) == RECORD_TYPE
)
3416 pp_string (pp
, "struct ");
3417 else if ((TREE_CODE (node
) == UNION_TYPE
3418 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3419 pp_string (pp
, "union ");
3421 dump_generic_node (pp
, TYPE_NAME (node
), spc
, 0, false);
3424 /* Print the contents of the structure. */
3430 /* Print the fields of the structure. */
3433 tmp
= TYPE_FIELDS (node
);
3436 /* Avoid to print recursively the structure. */
3437 /* FIXME : Not implemented correctly...,
3438 what about the case when we have a cycle in the contain graph? ...
3439 Maybe this could be solved by looking at the scope in which the
3440 structure was declared. */
3441 if (TREE_TYPE (tmp
) != node
3442 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3443 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3445 print_declaration (pp
, tmp
, spc
+2, flags
);
3448 tmp
= DECL_CHAIN (tmp
);
3452 pp_right_brace (pp
);
3455 /* Return the priority of the operator CODE.
3457 From lowest to highest precedence with either left-to-right (L-R)
3458 or right-to-left (R-L) associativity]:
3461 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3473 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3474 15 [L-R] fn() [] -> .
3476 unary +, - and * have higher precedence than the corresponding binary
3480 op_code_prio (enum tree_code code
)
3497 case TRUTH_ORIF_EXPR
:
3500 case TRUTH_AND_EXPR
:
3501 case TRUTH_ANDIF_EXPR
:
3508 case TRUTH_XOR_EXPR
:
3525 case UNORDERED_EXPR
:
3536 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3537 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3538 case WIDEN_LSHIFT_EXPR
:
3541 case WIDEN_SUM_EXPR
:
3543 case POINTER_PLUS_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 REDUC_MAX_EXPR
:
3596 case REDUC_MIN_EXPR
:
3597 case REDUC_PLUS_EXPR
:
3598 case VEC_UNPACK_HI_EXPR
:
3599 case VEC_UNPACK_LO_EXPR
:
3600 case VEC_UNPACK_FLOAT_HI_EXPR
:
3601 case VEC_UNPACK_FLOAT_LO_EXPR
:
3602 case VEC_PACK_TRUNC_EXPR
:
3603 case VEC_PACK_SAT_EXPR
:
3607 /* Return an arbitrarily high precedence to avoid surrounding single
3608 VAR_DECLs in ()s. */
3613 /* Return the priority of the operator OP. */
3616 op_prio (const_tree op
)
3618 enum tree_code code
;
3623 code
= TREE_CODE (op
);
3624 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3625 return op_prio (TREE_OPERAND (op
, 0));
3627 return op_code_prio (code
);
3630 /* Return the symbol associated with operator CODE. */
3633 op_symbol_code (enum tree_code code
)
3641 case TRUTH_ORIF_EXPR
:
3644 case TRUTH_AND_EXPR
:
3645 case TRUTH_ANDIF_EXPR
:
3651 case TRUTH_XOR_EXPR
:
3661 case UNORDERED_EXPR
:
3707 case WIDEN_LSHIFT_EXPR
:
3710 case POINTER_PLUS_EXPR
:
3716 case REDUC_PLUS_EXPR
:
3719 case WIDEN_SUM_EXPR
:
3722 case WIDEN_MULT_EXPR
:
3725 case MULT_HIGHPART_EXPR
:
3735 case TRUTH_NOT_EXPR
:
3742 case TRUNC_DIV_EXPR
:
3749 case FLOOR_DIV_EXPR
:
3752 case ROUND_DIV_EXPR
:
3755 case EXACT_DIV_EXPR
:
3758 case TRUNC_MOD_EXPR
:
3764 case FLOOR_MOD_EXPR
:
3767 case ROUND_MOD_EXPR
:
3770 case PREDECREMENT_EXPR
:
3773 case PREINCREMENT_EXPR
:
3776 case POSTDECREMENT_EXPR
:
3779 case POSTINCREMENT_EXPR
:
3789 return "<<< ??? >>>";
3793 /* Return the symbol associated with operator OP. */
3796 op_symbol (const_tree op
)
3798 return op_symbol_code (TREE_CODE (op
));
3801 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3802 the gimple_call_fn of a GIMPLE_CALL. */
3805 print_call_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
3809 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3810 op0
= TREE_OPERAND (op0
, 0);
3813 switch (TREE_CODE (op0
))
3818 dump_function_name (pp
, op0
, flags
);
3824 op0
= TREE_OPERAND (op0
, 0);
3829 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3830 pp_string (pp
, ") ? ");
3831 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3832 pp_string (pp
, " : ");
3833 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3837 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3838 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
3840 dump_generic_node (pp
, op0
, 0, flags
, false);
3844 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3846 op0
= TREE_OPERAND (op0
, 0);
3853 dump_generic_node (pp
, op0
, 0, flags
, false);
3861 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3864 pretty_print_string (pretty_printer
*pp
, const char *str
)
3874 pp_string (pp
, "\\b");
3878 pp_string (pp
, "\\f");
3882 pp_string (pp
, "\\n");
3886 pp_string (pp
, "\\r");
3890 pp_string (pp
, "\\t");
3894 pp_string (pp
, "\\v");
3898 pp_string (pp
, "\\\\");
3902 pp_string (pp
, "\\\"");
3906 pp_string (pp
, "\\'");
3909 /* No need to handle \0; the loop terminates on \0. */
3912 pp_string (pp
, "\\1");
3916 pp_string (pp
, "\\2");
3920 pp_string (pp
, "\\3");
3924 pp_string (pp
, "\\4");
3928 pp_string (pp
, "\\5");
3932 pp_string (pp
, "\\6");
3936 pp_string (pp
, "\\7");
3940 if (!ISPRINT (str
[0]))
3943 sprintf (buf
, "\\x%x", (unsigned char)str
[0]);
3944 pp_string (pp
, buf
);
3947 pp_character (pp
, str
[0]);
3955 maybe_init_pretty_print (FILE *file
)
3959 tree_pp
= new pretty_printer ();
3960 pp_needs_newline (tree_pp
) = true;
3961 pp_translate_identifiers (tree_pp
) = false;
3964 tree_pp
->buffer
->stream
= file
;
3968 newline_and_indent (pretty_printer
*pp
, int spc
)
3974 /* Handle the %K format for TEXT. Separate from default_tree_printer
3975 so it can also be used in front ends.
3976 Argument is a statement from which EXPR_LOCATION and TREE_BLOCK will
3980 percent_K_format (text_info
*text
, tree t
)
3982 text
->set_location (0, EXPR_LOCATION (t
), true);
3983 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3984 tree block
= TREE_BLOCK (t
);
3985 *pp_ti_abstract_origin (text
) = NULL
;
3989 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3990 representing the outermost block of an inlined function.
3991 So walk the BLOCK tree until we hit such a scope. */
3993 && TREE_CODE (block
) == BLOCK
)
3995 if (inlined_function_outer_scope_p (block
))
3997 *pp_ti_abstract_origin (text
) = block
;
4000 block
= BLOCK_SUPERCONTEXT (block
);
4006 && TREE_CODE (block
) == BLOCK
4007 && BLOCK_ABSTRACT_ORIGIN (block
))
4009 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
4011 while (TREE_CODE (ao
) == BLOCK
4012 && BLOCK_ABSTRACT_ORIGIN (ao
)
4013 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
4014 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
4016 if (TREE_CODE (ao
) == FUNCTION_DECL
)
4018 *pp_ti_abstract_origin (text
) = block
;
4021 block
= BLOCK_SUPERCONTEXT (block
);
4025 /* Print the identifier ID to PRETTY-PRINTER. */
4028 pp_tree_identifier (pretty_printer
*pp
, tree id
)
4030 if (pp_translate_identifiers (pp
))
4032 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
4033 pp_append_text (pp
, text
, text
+ strlen (text
));
4036 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
4037 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
4040 /* A helper function that is used to dump function information before the
4044 dump_function_header (FILE *dump_file
, tree fdecl
, dump_flags_t flags
)
4046 const char *dname
, *aname
;
4047 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
4048 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
4050 dname
= lang_hooks
.decl_printable_name (fdecl
, 1);
4052 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
4053 aname
= (IDENTIFIER_POINTER
4054 (DECL_ASSEMBLER_NAME (fdecl
)));
4056 aname
= "<unset-asm-name>";
4058 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
4059 dname
, aname
, fun
->funcdef_no
);
4060 if (!(flags
& TDF_NOUID
))
4061 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
4064 fprintf (dump_file
, ", cgraph_uid=%d", node
->uid
);
4065 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
4066 node
->frequency
== NODE_FREQUENCY_HOT
4068 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
4069 ? " (unlikely executed)"
4070 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
4071 ? " (executed once)"
4075 fprintf (dump_file
, ")\n\n");
4078 /* Dump double_int D to pretty_printer PP. UNS is true
4079 if D is unsigned and false otherwise. */
4081 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4084 pp_wide_integer (pp
, d
.low
);
4085 else if (d
.fits_uhwi ())
4086 pp_unsigned_wide_integer (pp
, d
.low
);
4089 unsigned HOST_WIDE_INT low
= d
.low
;
4090 HOST_WIDE_INT high
= d
.high
;
4091 if (!uns
&& d
.is_negative ())
4094 high
= ~high
+ !low
;
4097 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4099 sprintf (pp_buffer (pp
)->digit_buffer
,
4100 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4101 (unsigned HOST_WIDE_INT
) high
, low
);
4102 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);