1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2023 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.cc 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"
37 #include "fold-const.h"
39 /* Routines in this file get invoked via the default tree printer
40 used by diagnostics and thus they are called from pp_printf which
41 isn't reentrant. Avoid using pp_printf in this file. */
42 #pragma GCC poison pp_printf
44 /* Disable warnings about quoting issues in the pp_xxx calls below
45 that (intentionally) don't follow GCC diagnostic conventions. */
47 # pragma GCC diagnostic push
48 # pragma GCC diagnostic ignored "-Wformat-diag"
51 /* Local functions, macros and variables. */
52 static const char *op_symbol (const_tree
);
53 static void newline_and_indent (pretty_printer
*, int);
54 static void maybe_init_pretty_print (FILE *);
55 static void print_struct_decl (pretty_printer
*, const_tree
, int, dump_flags_t
);
56 static void do_niy (pretty_printer
*, const_tree
, int, dump_flags_t
);
58 #define INDENT(SPACE) do { \
59 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
61 #define NIY do_niy (pp, node, spc, flags)
63 static pretty_printer
*tree_pp
;
65 /* Try to print something for an unknown tree code. */
68 do_niy (pretty_printer
*pp
, const_tree node
, int spc
, dump_flags_t flags
)
72 pp_string (pp
, "<<< Unknown tree: ");
73 pp_string (pp
, get_tree_code_name (TREE_CODE (node
)));
77 len
= TREE_OPERAND_LENGTH (node
);
78 for (i
= 0; i
< len
; ++i
)
80 newline_and_indent (pp
, spc
+2);
81 dump_generic_node (pp
, TREE_OPERAND (node
, i
), spc
+2, flags
, false);
85 pp_string (pp
, " >>>");
88 /* Debugging function to print out a generic expression. */
91 debug_generic_expr (tree t
)
93 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
94 fprintf (stderr
, "\n");
97 /* Debugging function to print out a generic statement. */
100 debug_generic_stmt (tree t
)
102 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
103 fprintf (stderr
, "\n");
106 /* Debugging function to print out a chain of trees . */
109 debug_tree_chain (tree t
)
115 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
116 fprintf (stderr
, " ");
120 fprintf (stderr
, "... [cycled back to ");
121 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
122 fprintf (stderr
, "]");
126 fprintf (stderr
, "\n");
129 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
131 print_generic_decl (FILE *file
, tree decl
, dump_flags_t flags
)
133 maybe_init_pretty_print (file
);
134 print_declaration (tree_pp
, decl
, 2, flags
);
135 pp_write_text_to_stream (tree_pp
);
138 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
139 to show in the dump. See TDF_* in dumpfile.h. */
142 print_generic_stmt (FILE *file
, tree t
, dump_flags_t flags
)
144 maybe_init_pretty_print (file
);
145 dump_generic_node (tree_pp
, t
, 0, flags
, true);
146 pp_newline_and_flush (tree_pp
);
149 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
150 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
154 print_generic_stmt_indented (FILE *file
, tree t
, dump_flags_t flags
, int indent
)
158 maybe_init_pretty_print (file
);
160 for (i
= 0; i
< indent
; i
++)
162 dump_generic_node (tree_pp
, t
, indent
, flags
, true);
163 pp_newline_and_flush (tree_pp
);
166 /* Print a single expression T on file FILE. FLAGS specifies details to show
167 in the dump. See TDF_* in dumpfile.h. */
170 print_generic_expr (FILE *file
, tree t
, dump_flags_t flags
)
172 maybe_init_pretty_print (file
);
173 dump_generic_node (tree_pp
, t
, 0, flags
, false);
177 /* Print a single expression T to string, and return it. The caller
178 must free the returned memory. */
181 print_generic_expr_to_str (tree t
)
184 dump_generic_node (&pp
, t
, 0, TDF_VOPS
|TDF_MEMSYMS
, false);
185 return xstrdup (pp_formatted_text (&pp
));
188 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
189 in it are replaced with Dxxxx, as long as they are at the start or
190 preceded by $ and at the end or followed by $. See make_fancy_name
194 dump_fancy_name (pretty_printer
*pp
, tree name
)
197 int length
= IDENTIFIER_LENGTH (name
);
198 const char *n
= IDENTIFIER_POINTER (name
);
205 && (n
== IDENTIFIER_POINTER (name
) || n
[-1] == '$'))
208 while (ISDIGIT (n
[l
]))
210 if (n
[l
] == '\0' || n
[l
] == '$')
223 pp_tree_identifier (pp
, name
);
227 char *str
= XNEWVEC (char, length
+ 1);
230 q
= n
= IDENTIFIER_POINTER (name
);
237 && (q
== IDENTIFIER_POINTER (name
) || q
[-1] == '$'))
240 while (ISDIGIT (q
[l
]))
242 if (q
[l
] == '\0' || q
[l
] == '$')
244 memcpy (p
, n
, q
- n
);
245 memcpy (p
+ (q
- n
), "Dxxxx", 5);
255 memcpy (p
, n
, IDENTIFIER_LENGTH (name
) - (n
- IDENTIFIER_POINTER (name
)));
257 if (pp_translate_identifiers (pp
))
259 const char *text
= identifier_to_locale (str
);
260 pp_append_text (pp
, text
, text
+ strlen (text
));
263 pp_append_text (pp
, str
, str
+ length
);
267 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
271 dump_decl_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
273 tree name
= DECL_NAME (node
);
276 if ((flags
& TDF_ASMNAME
)
277 && HAS_DECL_ASSEMBLER_NAME_P (node
)
278 && DECL_ASSEMBLER_NAME_SET_P (node
))
279 pp_tree_identifier (pp
, DECL_ASSEMBLER_NAME_RAW (node
));
280 /* For -fcompare-debug don't dump DECL_NAMELESS names at all,
281 -g might have created more fancy names and their indexes
282 could get out of sync. Usually those should be DECL_IGNORED_P
283 too, SRA can create even non-DECL_IGNORED_P DECL_NAMELESS fancy
284 names, let's hope those never get out of sync after doing the
285 dump_fancy_name sanitization. */
286 else if ((flags
& TDF_COMPARE_DEBUG
)
287 && DECL_NAMELESS (node
)
288 && DECL_IGNORED_P (node
))
290 /* For DECL_NAMELESS names look for embedded uids in the
291 names and sanitize them for TDF_NOUID. */
292 else if ((flags
& TDF_NOUID
) && DECL_NAMELESS (node
))
293 dump_fancy_name (pp
, name
);
295 pp_tree_identifier (pp
, name
);
297 char uid_sep
= (flags
& TDF_GIMPLE
) ? '_' : '.';
298 if ((flags
& TDF_UID
) || name
== NULL_TREE
)
300 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
302 pp_character (pp
, 'L');
303 pp_character (pp
, uid_sep
);
304 pp_decimal_int (pp
, (int) LABEL_DECL_UID (node
));
306 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
308 if (flags
& TDF_NOUID
)
309 pp_string (pp
, "D#xxxx");
312 pp_string (pp
, "D#");
313 pp_decimal_int (pp
, (int) DEBUG_TEMP_UID (node
));
318 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
319 pp_character (pp
, c
);
320 pp_character (pp
, uid_sep
);
321 if (flags
& TDF_NOUID
)
322 pp_string (pp
, "xxxx");
324 pp_scalar (pp
, "%u", DECL_UID (node
));
327 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
329 if (flags
& TDF_NOUID
)
330 pp_string (pp
, "ptD.xxxx");
333 pp_string (pp
, "ptD.");
334 pp_scalar (pp
, "%u", DECL_PT_UID (node
));
339 /* Like the above, but used for pretty printing function calls. */
342 dump_function_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
344 if (CONVERT_EXPR_P (node
))
345 node
= TREE_OPERAND (node
, 0);
346 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
348 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
351 char uid_sep
= (flags
& TDF_GIMPLE
) ? '_' : '.';
352 pp_character (pp
, 'D');
353 pp_character (pp
, uid_sep
);
354 pp_scalar (pp
, "%u", DECL_UID (node
));
358 dump_decl_name (pp
, node
, flags
);
361 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
362 FLAGS are as in dump_generic_node. */
365 dump_function_declaration (pretty_printer
*pp
, tree node
,
366 int spc
, dump_flags_t flags
)
368 bool wrote_arg
= false;
374 /* Print the argument types. */
375 arg
= TYPE_ARG_TYPES (node
);
376 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
384 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
385 arg
= TREE_CHAIN (arg
);
388 /* Drop the trailing void_type_node if we had any previous argument. */
389 if (arg
== void_list_node
&& !wrote_arg
)
390 pp_string (pp
, "void");
391 /* Properly dump vararg function types. */
392 else if (!arg
&& wrote_arg
)
393 pp_string (pp
, ", ...");
394 /* Avoid printing any arg for unprototyped functions. */
399 /* Dump the domain associated with an array. */
402 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, dump_flags_t flags
)
404 pp_left_bracket (pp
);
407 tree min
= TYPE_MIN_VALUE (domain
);
408 tree max
= TYPE_MAX_VALUE (domain
);
411 && integer_zerop (min
)
412 && tree_fits_shwi_p (max
))
413 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
417 dump_generic_node (pp
, min
, spc
, flags
, false);
420 dump_generic_node (pp
, max
, spc
, flags
, false);
424 pp_string (pp
, "<unknown>");
425 pp_right_bracket (pp
);
429 /* Dump OpenMP iterators ITER. */
432 dump_omp_iterators (pretty_printer
*pp
, tree iter
, int spc
, dump_flags_t flags
)
434 pp_string (pp
, "iterator(");
435 for (tree it
= iter
; it
; it
= TREE_CHAIN (it
))
438 pp_string (pp
, ", ");
439 dump_generic_node (pp
, TREE_TYPE (TREE_VEC_ELT (it
, 0)), spc
, flags
,
442 dump_generic_node (pp
, TREE_VEC_ELT (it
, 0), spc
, flags
, false);
444 dump_generic_node (pp
, TREE_VEC_ELT (it
, 1), spc
, flags
, false);
446 dump_generic_node (pp
, TREE_VEC_ELT (it
, 2), spc
, flags
, false);
448 dump_generic_node (pp
, TREE_VEC_ELT (it
, 3), spc
, flags
, false);
454 /* Dump OMP clause CLAUSE, without following OMP_CLAUSE_CHAIN.
456 PP, CLAUSE, SPC and FLAGS are as in dump_generic_node. */
459 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
462 const char *modifier
= NULL
;
463 switch (OMP_CLAUSE_CODE (clause
))
465 case OMP_CLAUSE_PRIVATE
:
468 case OMP_CLAUSE_SHARED
:
471 case OMP_CLAUSE_FIRSTPRIVATE
:
472 name
= "firstprivate";
474 case OMP_CLAUSE_LASTPRIVATE
:
475 name
= "lastprivate";
476 if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clause
))
477 modifier
= "conditional:";
479 case OMP_CLAUSE_COPYIN
:
482 case OMP_CLAUSE_COPYPRIVATE
:
483 name
= "copyprivate";
485 case OMP_CLAUSE_UNIFORM
:
488 case OMP_CLAUSE_USE_DEVICE_PTR
:
489 name
= "use_device_ptr";
490 if (OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT (clause
))
491 modifier
= "if_present:";
493 case OMP_CLAUSE_USE_DEVICE_ADDR
:
494 name
= "use_device_addr";
496 case OMP_CLAUSE_HAS_DEVICE_ADDR
:
497 name
= "has_device_addr";
499 case OMP_CLAUSE_IS_DEVICE_PTR
:
500 name
= "is_device_ptr";
502 case OMP_CLAUSE_INCLUSIVE
:
505 case OMP_CLAUSE_EXCLUSIVE
:
508 case OMP_CLAUSE__LOOPTEMP_
:
511 case OMP_CLAUSE__REDUCTEMP_
:
512 name
= "_reductemp_";
514 case OMP_CLAUSE__CONDTEMP_
:
517 case OMP_CLAUSE__SCANTEMP_
:
520 case OMP_CLAUSE_ENTER
:
521 if (OMP_CLAUSE_ENTER_TO (clause
))
526 case OMP_CLAUSE_LINK
:
529 case OMP_CLAUSE_NONTEMPORAL
:
530 name
= "nontemporal";
533 pp_string (pp
, name
);
536 pp_string (pp
, modifier
);
537 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
542 case OMP_CLAUSE_TASK_REDUCTION
:
543 case OMP_CLAUSE_IN_REDUCTION
:
544 pp_string (pp
, OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_IN_REDUCTION
547 case OMP_CLAUSE_REDUCTION
:
548 pp_string (pp
, "reduction(");
549 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_REDUCTION
)
551 if (OMP_CLAUSE_REDUCTION_TASK (clause
))
552 pp_string (pp
, "task,");
553 else if (OMP_CLAUSE_REDUCTION_INSCAN (clause
))
554 pp_string (pp
, "inscan,");
556 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
559 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
562 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
568 pp_string (pp
, "if(");
569 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
571 case ERROR_MARK
: break;
572 case VOID_CST
: pp_string (pp
, "cancel:"); break;
573 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
574 case OMP_SIMD
: pp_string (pp
, "simd:"); break;
575 case OMP_TASK
: pp_string (pp
, "task:"); break;
576 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
577 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
578 case OMP_TARGET
: pp_string (pp
, "target:"); break;
579 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
580 case OMP_TARGET_ENTER_DATA
:
581 pp_string (pp
, "target enter data:"); break;
582 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
583 default: gcc_unreachable ();
585 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
590 case OMP_CLAUSE_NUM_THREADS
:
591 pp_string (pp
, "num_threads(");
592 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
597 case OMP_CLAUSE_NOWAIT
:
598 pp_string (pp
, "nowait");
600 case OMP_CLAUSE_ORDERED
:
601 pp_string (pp
, "ordered");
602 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
605 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
611 case OMP_CLAUSE_DEFAULT
:
612 pp_string (pp
, "default(");
613 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
615 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
617 case OMP_CLAUSE_DEFAULT_SHARED
:
618 pp_string (pp
, "shared");
620 case OMP_CLAUSE_DEFAULT_NONE
:
621 pp_string (pp
, "none");
623 case OMP_CLAUSE_DEFAULT_PRIVATE
:
624 pp_string (pp
, "private");
626 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
627 pp_string (pp
, "firstprivate");
629 case OMP_CLAUSE_DEFAULT_PRESENT
:
630 pp_string (pp
, "present");
638 case OMP_CLAUSE_SCHEDULE
:
639 pp_string (pp
, "schedule(");
640 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
641 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
642 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
644 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
645 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
646 pp_string (pp
, "monotonic");
648 pp_string (pp
, "nonmonotonic");
649 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
654 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
655 pp_string (pp
, "simd:");
657 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
659 case OMP_CLAUSE_SCHEDULE_STATIC
:
660 pp_string (pp
, "static");
662 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
663 pp_string (pp
, "dynamic");
665 case OMP_CLAUSE_SCHEDULE_GUIDED
:
666 pp_string (pp
, "guided");
668 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
669 pp_string (pp
, "runtime");
671 case OMP_CLAUSE_SCHEDULE_AUTO
:
672 pp_string (pp
, "auto");
677 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
680 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
686 case OMP_CLAUSE_UNTIED
:
687 pp_string (pp
, "untied");
690 case OMP_CLAUSE_COLLAPSE
:
691 pp_string (pp
, "collapse(");
692 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
697 case OMP_CLAUSE_FINAL
:
698 pp_string (pp
, "final(");
699 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
704 case OMP_CLAUSE_MERGEABLE
:
705 pp_string (pp
, "mergeable");
708 case OMP_CLAUSE_LINEAR
:
709 pp_string (pp
, "linear(");
710 if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause
))
711 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
713 case OMP_CLAUSE_LINEAR_DEFAULT
:
715 case OMP_CLAUSE_LINEAR_REF
:
716 pp_string (pp
, "ref(");
718 case OMP_CLAUSE_LINEAR_VAL
:
719 pp_string (pp
, "val(");
721 case OMP_CLAUSE_LINEAR_UVAL
:
722 pp_string (pp
, "uval(");
727 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
729 if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause
)
730 && OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
733 if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause
)
734 && OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
735 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
737 case OMP_CLAUSE_LINEAR_REF
:
738 pp_string (pp
, "ref,step(");
740 case OMP_CLAUSE_LINEAR_VAL
:
741 pp_string (pp
, "val,step(");
743 case OMP_CLAUSE_LINEAR_UVAL
:
744 pp_string (pp
, "uval,step(");
749 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
751 if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause
)
752 && OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
757 case OMP_CLAUSE_ALIGNED
:
758 pp_string (pp
, "aligned(");
759 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
761 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
764 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
770 case OMP_CLAUSE_ALLOCATE
:
771 pp_string (pp
, "allocate(");
772 if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause
))
774 pp_string (pp
, "allocator(");
775 dump_generic_node (pp
, OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause
),
779 if (OMP_CLAUSE_ALLOCATE_ALIGN (clause
))
781 if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause
))
783 pp_string (pp
, "align(");
784 dump_generic_node (pp
, OMP_CLAUSE_ALLOCATE_ALIGN (clause
),
788 if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause
)
789 || OMP_CLAUSE_ALLOCATE_ALIGN (clause
))
791 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
796 case OMP_CLAUSE_AFFINITY
:
797 pp_string (pp
, "affinity(");
799 tree t
= OMP_CLAUSE_DECL (clause
);
800 if (TREE_CODE (t
) == TREE_LIST
802 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
804 dump_omp_iterators (pp
, TREE_PURPOSE (t
), spc
, flags
);
808 dump_generic_node (pp
, t
, spc
, flags
, false);
812 case OMP_CLAUSE_DEPEND
:
813 pp_string (pp
, "depend(");
814 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
816 case OMP_CLAUSE_DEPEND_DEPOBJ
:
819 case OMP_CLAUSE_DEPEND_IN
:
822 case OMP_CLAUSE_DEPEND_OUT
:
825 case OMP_CLAUSE_DEPEND_INOUT
:
828 case OMP_CLAUSE_DEPEND_MUTEXINOUTSET
:
829 name
= "mutexinoutset";
831 case OMP_CLAUSE_DEPEND_INOUTSET
:
834 case OMP_CLAUSE_DEPEND_LAST
:
835 name
= "__internal__";
841 tree t
= OMP_CLAUSE_DECL (clause
);
842 if (TREE_CODE (t
) == TREE_LIST
844 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
846 dump_omp_iterators (pp
, TREE_PURPOSE (t
), spc
, flags
);
852 pp_string (pp
, name
);
855 if (t
== null_pointer_node
)
856 pp_string (pp
, "omp_all_memory");
858 dump_generic_node (pp
, t
, spc
, flags
, false);
863 case OMP_CLAUSE_DOACROSS
:
864 pp_string (pp
, OMP_CLAUSE_DOACROSS_DEPEND (clause
)
865 ? "depend(" : "doacross(");
866 switch (OMP_CLAUSE_DOACROSS_KIND (clause
))
868 case OMP_CLAUSE_DOACROSS_SOURCE
:
869 if (OMP_CLAUSE_DOACROSS_DEPEND (clause
))
870 pp_string (pp
, "source)");
872 pp_string (pp
, "source:)");
874 case OMP_CLAUSE_DOACROSS_SINK
:
875 pp_string (pp
, "sink:");
876 if (OMP_CLAUSE_DECL (clause
) == NULL_TREE
)
878 pp_string (pp
, "omp_cur_iteration-1)");
881 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
882 if (TREE_CODE (t
) == TREE_LIST
)
884 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
885 if (TREE_PURPOSE (t
) != integer_zero_node
)
887 if (OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (t
))
891 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
907 pp_string (pp
, "map(");
908 switch (OMP_CLAUSE_MAP_KIND (clause
))
911 case GOMP_MAP_POINTER
:
912 case GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION
:
913 pp_string (pp
, "alloc");
915 case GOMP_MAP_IF_PRESENT
:
916 pp_string (pp
, "no_alloc");
919 case GOMP_MAP_TO_PSET
:
920 pp_string (pp
, "to");
923 pp_string (pp
, "from");
925 case GOMP_MAP_TOFROM
:
926 pp_string (pp
, "tofrom");
928 case GOMP_MAP_FORCE_ALLOC
:
929 pp_string (pp
, "force_alloc");
931 case GOMP_MAP_FORCE_TO
:
932 pp_string (pp
, "force_to");
934 case GOMP_MAP_FORCE_FROM
:
935 pp_string (pp
, "force_from");
937 case GOMP_MAP_FORCE_TOFROM
:
938 pp_string (pp
, "force_tofrom");
940 case GOMP_MAP_FORCE_PRESENT
:
941 pp_string (pp
, "force_present");
943 case GOMP_MAP_DELETE
:
944 pp_string (pp
, "delete");
946 case GOMP_MAP_FORCE_DEVICEPTR
:
947 pp_string (pp
, "force_deviceptr");
949 case GOMP_MAP_ALWAYS_TO
:
950 pp_string (pp
, "always,to");
952 case GOMP_MAP_ALWAYS_FROM
:
953 pp_string (pp
, "always,from");
955 case GOMP_MAP_ALWAYS_TOFROM
:
956 pp_string (pp
, "always,tofrom");
958 case GOMP_MAP_RELEASE
:
959 pp_string (pp
, "release");
961 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
962 pp_string (pp
, "firstprivate");
964 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
965 pp_string (pp
, "firstprivate ref");
967 case GOMP_MAP_STRUCT
:
968 pp_string (pp
, "struct");
970 case GOMP_MAP_ALWAYS_POINTER
:
971 pp_string (pp
, "always_pointer");
973 case GOMP_MAP_DEVICE_RESIDENT
:
974 pp_string (pp
, "device_resident");
977 pp_string (pp
, "link");
979 case GOMP_MAP_ATTACH
:
980 pp_string (pp
, "attach");
982 case GOMP_MAP_DETACH
:
983 pp_string (pp
, "detach");
985 case GOMP_MAP_FORCE_DETACH
:
986 pp_string (pp
, "force_detach");
988 case GOMP_MAP_ATTACH_DETACH
:
989 pp_string (pp
, "attach_detach");
991 case GOMP_MAP_ATTACH_ZERO_LENGTH_ARRAY_SECTION
:
992 pp_string (pp
, "attach_zero_length_array_section");
994 case GOMP_MAP_PRESENT_ALLOC
:
995 pp_string (pp
, "present,alloc");
997 case GOMP_MAP_PRESENT_TO
:
998 pp_string (pp
, "present,to");
1000 case GOMP_MAP_PRESENT_FROM
:
1001 pp_string (pp
, "present,from");
1003 case GOMP_MAP_PRESENT_TOFROM
:
1004 pp_string (pp
, "present,tofrom");
1006 case GOMP_MAP_ALWAYS_PRESENT_TO
:
1007 pp_string (pp
, "always,present,to");
1009 case GOMP_MAP_ALWAYS_PRESENT_FROM
:
1010 pp_string (pp
, "always,present,from");
1012 case GOMP_MAP_ALWAYS_PRESENT_TOFROM
:
1013 pp_string (pp
, "always,present,tofrom");
1019 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
1022 if (OMP_CLAUSE_SIZE (clause
))
1024 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
1025 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
1027 case GOMP_MAP_POINTER
:
1028 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
1029 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
1030 case GOMP_MAP_ALWAYS_POINTER
:
1031 pp_string (pp
, " [pointer assign, bias: ");
1033 case GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION
:
1034 pp_string (pp
, " [pointer assign, zero-length array section, bias: ");
1036 case GOMP_MAP_TO_PSET
:
1037 pp_string (pp
, " [pointer set, len: ");
1039 case GOMP_MAP_ATTACH
:
1040 case GOMP_MAP_DETACH
:
1041 case GOMP_MAP_FORCE_DETACH
:
1042 case GOMP_MAP_ATTACH_DETACH
:
1043 case GOMP_MAP_ATTACH_ZERO_LENGTH_ARRAY_SECTION
:
1044 pp_string (pp
, " [bias: ");
1047 pp_string (pp
, " [len: ");
1050 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
1052 pp_right_bracket (pp
);
1054 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
1055 && OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P (clause
))
1056 pp_string (pp
, "[implicit]");
1057 pp_right_paren (pp
);
1060 case OMP_CLAUSE_FROM
:
1061 pp_string (pp
, "from(");
1062 if (OMP_CLAUSE_MOTION_PRESENT (clause
))
1063 pp_string (pp
, "present:");
1064 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
1066 goto print_clause_size
;
1069 pp_string (pp
, "to(");
1070 if (OMP_CLAUSE_MOTION_PRESENT (clause
))
1071 pp_string (pp
, "present:");
1072 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
1074 goto print_clause_size
;
1076 case OMP_CLAUSE__CACHE_
:
1077 pp_string (pp
, "(");
1078 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
1080 goto print_clause_size
;
1082 case OMP_CLAUSE_NUM_TEAMS
:
1083 pp_string (pp
, "num_teams(");
1084 if (OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (clause
))
1086 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (clause
),
1090 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR (clause
),
1092 pp_right_paren (pp
);
1095 case OMP_CLAUSE_THREAD_LIMIT
:
1096 pp_string (pp
, "thread_limit(");
1097 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
1099 pp_right_paren (pp
);
1102 case OMP_CLAUSE_DEVICE
:
1103 pp_string (pp
, "device(");
1104 if (OMP_CLAUSE_DEVICE_ANCESTOR (clause
))
1105 pp_string (pp
, "ancestor:");
1106 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
1108 pp_right_paren (pp
);
1111 case OMP_CLAUSE_DIST_SCHEDULE
:
1112 pp_string (pp
, "dist_schedule(static");
1113 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
1116 dump_generic_node (pp
,
1117 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
1120 pp_right_paren (pp
);
1123 case OMP_CLAUSE_PROC_BIND
:
1124 pp_string (pp
, "proc_bind(");
1125 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
1127 case OMP_CLAUSE_PROC_BIND_MASTER
:
1128 /* Same enum value: case OMP_CLAUSE_PROC_BIND_PRIMARY: */
1129 /* TODO: Change to 'primary' for OpenMP 5.1. */
1130 pp_string (pp
, "master");
1132 case OMP_CLAUSE_PROC_BIND_CLOSE
:
1133 pp_string (pp
, "close");
1135 case OMP_CLAUSE_PROC_BIND_SPREAD
:
1136 pp_string (pp
, "spread");
1141 pp_right_paren (pp
);
1144 case OMP_CLAUSE_DEVICE_TYPE
:
1145 pp_string (pp
, "device_type(");
1146 switch (OMP_CLAUSE_DEVICE_TYPE_KIND (clause
))
1148 case OMP_CLAUSE_DEVICE_TYPE_HOST
:
1149 pp_string (pp
, "host");
1151 case OMP_CLAUSE_DEVICE_TYPE_NOHOST
:
1152 pp_string (pp
, "nohost");
1154 case OMP_CLAUSE_DEVICE_TYPE_ANY
:
1155 pp_string (pp
, "any");
1160 pp_right_paren (pp
);
1163 case OMP_CLAUSE_SAFELEN
:
1164 pp_string (pp
, "safelen(");
1165 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
1167 pp_right_paren (pp
);
1170 case OMP_CLAUSE_SIMDLEN
:
1171 pp_string (pp
, "simdlen(");
1172 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
1174 pp_right_paren (pp
);
1177 case OMP_CLAUSE_PRIORITY
:
1178 pp_string (pp
, "priority(");
1179 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
1181 pp_right_paren (pp
);
1184 case OMP_CLAUSE_GRAINSIZE
:
1185 pp_string (pp
, "grainsize(");
1186 if (OMP_CLAUSE_GRAINSIZE_STRICT (clause
))
1187 pp_string (pp
, "strict:");
1188 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
1190 pp_right_paren (pp
);
1193 case OMP_CLAUSE_NUM_TASKS
:
1194 pp_string (pp
, "num_tasks(");
1195 if (OMP_CLAUSE_NUM_TASKS_STRICT (clause
))
1196 pp_string (pp
, "strict:");
1197 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
1199 pp_right_paren (pp
);
1202 case OMP_CLAUSE_HINT
:
1203 pp_string (pp
, "hint(");
1204 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
1206 pp_right_paren (pp
);
1209 case OMP_CLAUSE_FILTER
:
1210 pp_string (pp
, "filter(");
1211 dump_generic_node (pp
, OMP_CLAUSE_FILTER_EXPR (clause
),
1213 pp_right_paren (pp
);
1216 case OMP_CLAUSE_DEFAULTMAP
:
1217 pp_string (pp
, "defaultmap(");
1218 switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (clause
))
1220 case OMP_CLAUSE_DEFAULTMAP_ALLOC
:
1221 pp_string (pp
, "alloc");
1223 case OMP_CLAUSE_DEFAULTMAP_TO
:
1224 pp_string (pp
, "to");
1226 case OMP_CLAUSE_DEFAULTMAP_FROM
:
1227 pp_string (pp
, "from");
1229 case OMP_CLAUSE_DEFAULTMAP_TOFROM
:
1230 pp_string (pp
, "tofrom");
1232 case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE
:
1233 pp_string (pp
, "firstprivate");
1235 case OMP_CLAUSE_DEFAULTMAP_NONE
:
1236 pp_string (pp
, "none");
1238 case OMP_CLAUSE_DEFAULTMAP_PRESENT
:
1239 pp_string (pp
, "present");
1241 case OMP_CLAUSE_DEFAULTMAP_DEFAULT
:
1242 pp_string (pp
, "default");
1247 switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (clause
))
1249 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED
:
1251 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR
:
1252 pp_string (pp
, ":scalar");
1254 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE
:
1255 pp_string (pp
, ":aggregate");
1257 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE
:
1258 pp_string (pp
, ":allocatable");
1260 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER
:
1261 pp_string (pp
, ":pointer");
1266 pp_right_paren (pp
);
1269 case OMP_CLAUSE_ORDER
:
1270 pp_string (pp
, "order(");
1271 if (OMP_CLAUSE_ORDER_UNCONSTRAINED (clause
))
1272 pp_string (pp
, "unconstrained:");
1273 else if (OMP_CLAUSE_ORDER_REPRODUCIBLE (clause
))
1274 pp_string (pp
, "reproducible:");
1275 pp_string (pp
, "concurrent)");
1278 case OMP_CLAUSE_BIND
:
1279 pp_string (pp
, "bind(");
1280 switch (OMP_CLAUSE_BIND_KIND (clause
))
1282 case OMP_CLAUSE_BIND_TEAMS
:
1283 pp_string (pp
, "teams");
1285 case OMP_CLAUSE_BIND_PARALLEL
:
1286 pp_string (pp
, "parallel");
1288 case OMP_CLAUSE_BIND_THREAD
:
1289 pp_string (pp
, "thread");
1294 pp_right_paren (pp
);
1297 case OMP_CLAUSE__SIMDUID_
:
1298 pp_string (pp
, "_simduid_(");
1299 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
1301 pp_right_paren (pp
);
1304 case OMP_CLAUSE__SIMT_
:
1305 pp_string (pp
, "_simt_");
1308 case OMP_CLAUSE_GANG
:
1309 pp_string (pp
, "gang");
1310 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
1312 pp_string (pp
, "(num: ");
1313 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
1316 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
1318 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
1322 pp_string (pp
, "static:");
1323 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
1324 == integer_minus_one_node
)
1325 pp_character (pp
, '*');
1327 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
1330 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
1331 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
1332 pp_right_paren (pp
);
1335 case OMP_CLAUSE_ASYNC
:
1336 pp_string (pp
, "async");
1337 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
1339 pp_character(pp
, '(');
1340 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
1342 pp_character(pp
, ')');
1346 case OMP_CLAUSE_AUTO
:
1347 case OMP_CLAUSE_SEQ
:
1348 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
1351 case OMP_CLAUSE_WAIT
:
1352 pp_string (pp
, "wait(");
1353 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
1355 pp_character(pp
, ')');
1358 case OMP_CLAUSE_WORKER
:
1359 pp_string (pp
, "worker");
1360 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
1363 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
1365 pp_right_paren (pp
);
1369 case OMP_CLAUSE_VECTOR
:
1370 pp_string (pp
, "vector");
1371 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
1374 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
1376 pp_right_paren (pp
);
1380 case OMP_CLAUSE_NUM_GANGS
:
1381 pp_string (pp
, "num_gangs(");
1382 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
1384 pp_character (pp
, ')');
1387 case OMP_CLAUSE_NUM_WORKERS
:
1388 pp_string (pp
, "num_workers(");
1389 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
1391 pp_character (pp
, ')');
1394 case OMP_CLAUSE_VECTOR_LENGTH
:
1395 pp_string (pp
, "vector_length(");
1396 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
1398 pp_character (pp
, ')');
1401 case OMP_CLAUSE_INBRANCH
:
1402 pp_string (pp
, "inbranch");
1404 case OMP_CLAUSE_NOTINBRANCH
:
1405 pp_string (pp
, "notinbranch");
1407 case OMP_CLAUSE_FOR
:
1408 pp_string (pp
, "for");
1410 case OMP_CLAUSE_PARALLEL
:
1411 pp_string (pp
, "parallel");
1413 case OMP_CLAUSE_SECTIONS
:
1414 pp_string (pp
, "sections");
1416 case OMP_CLAUSE_TASKGROUP
:
1417 pp_string (pp
, "taskgroup");
1419 case OMP_CLAUSE_NOGROUP
:
1420 pp_string (pp
, "nogroup");
1422 case OMP_CLAUSE_THREADS
:
1423 pp_string (pp
, "threads");
1425 case OMP_CLAUSE_SIMD
:
1426 pp_string (pp
, "simd");
1428 case OMP_CLAUSE_INDEPENDENT
:
1429 pp_string (pp
, "independent");
1431 case OMP_CLAUSE_TILE
:
1432 pp_string (pp
, "tile(");
1433 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1435 pp_right_paren (pp
);
1438 case OMP_CLAUSE_IF_PRESENT
:
1439 pp_string (pp
, "if_present");
1441 case OMP_CLAUSE_FINALIZE
:
1442 pp_string (pp
, "finalize");
1444 case OMP_CLAUSE_NOHOST
:
1445 pp_string (pp
, "nohost");
1447 case OMP_CLAUSE_DETACH
:
1448 pp_string (pp
, "detach(");
1449 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
), spc
, flags
,
1451 pp_right_paren (pp
);
1460 /* Dump chain of OMP clauses.
1462 PP, SPC and FLAGS are as in dump_generic_node. */
1465 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
,
1472 dump_omp_clause (pp
, clause
, spc
, flags
);
1473 leading_space
= true;
1475 clause
= OMP_CLAUSE_CHAIN (clause
);
1480 /* Dump location LOC to PP. */
1483 dump_location (pretty_printer
*pp
, location_t loc
)
1485 expanded_location xloc
= expand_location (loc
);
1486 int discriminator
= get_discriminator_from_loc (loc
);
1488 pp_left_bracket (pp
);
1491 pp_string (pp
, xloc
.file
);
1492 pp_string (pp
, ":");
1494 pp_decimal_int (pp
, xloc
.line
);
1496 pp_decimal_int (pp
, xloc
.column
);
1499 pp_string (pp
, " discrim ");
1500 pp_decimal_int (pp
, discriminator
);
1502 pp_string (pp
, "] ");
1506 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1507 dump_generic_node. */
1510 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, dump_flags_t flags
)
1514 pp_string (pp
, "BLOCK #");
1515 pp_decimal_int (pp
, BLOCK_NUMBER (block
));
1516 pp_character (pp
, ' ');
1518 if (flags
& TDF_ADDRESS
)
1520 pp_character (pp
, '[');
1521 pp_scalar (pp
, "%p", (void *) block
);
1522 pp_string (pp
, "] ");
1525 if (TREE_ASM_WRITTEN (block
))
1526 pp_string (pp
, "[written] ");
1528 if (flags
& TDF_SLIM
)
1531 if (BLOCK_SOURCE_LOCATION (block
))
1532 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1534 newline_and_indent (pp
, spc
+ 2);
1536 if (BLOCK_SUPERCONTEXT (block
))
1538 pp_string (pp
, "SUPERCONTEXT: ");
1539 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1540 flags
| TDF_SLIM
, false);
1541 newline_and_indent (pp
, spc
+ 2);
1544 if (BLOCK_SUBBLOCKS (block
))
1546 pp_string (pp
, "SUBBLOCKS: ");
1547 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1549 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1552 newline_and_indent (pp
, spc
+ 2);
1555 if (BLOCK_CHAIN (block
))
1557 pp_string (pp
, "SIBLINGS: ");
1558 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1560 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1563 newline_and_indent (pp
, spc
+ 2);
1566 if (BLOCK_VARS (block
))
1568 pp_string (pp
, "VARS: ");
1569 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1571 dump_generic_node (pp
, t
, 0, flags
, false);
1574 newline_and_indent (pp
, spc
+ 2);
1577 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1580 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1582 pp_string (pp
, "NONLOCALIZED_VARS: ");
1583 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1585 dump_generic_node (pp
, t
, 0, flags
, false);
1588 newline_and_indent (pp
, spc
+ 2);
1591 if (BLOCK_ABSTRACT_ORIGIN (block
))
1593 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1594 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1595 flags
| TDF_SLIM
, false);
1596 newline_and_indent (pp
, spc
+ 2);
1599 if (BLOCK_FRAGMENT_ORIGIN (block
))
1601 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1602 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1603 flags
| TDF_SLIM
, false);
1604 newline_and_indent (pp
, spc
+ 2);
1607 if (BLOCK_FRAGMENT_CHAIN (block
))
1609 pp_string (pp
, "FRAGMENT_CHAIN: ");
1610 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1612 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1615 newline_and_indent (pp
, spc
+ 2);
1619 /* Dump #pragma omp atomic memory order clause. */
1622 dump_omp_atomic_memory_order (pretty_printer
*pp
, enum omp_memory_order mo
)
1624 switch (mo
& OMP_MEMORY_ORDER_MASK
)
1626 case OMP_MEMORY_ORDER_RELAXED
:
1627 pp_string (pp
, " relaxed");
1629 case OMP_MEMORY_ORDER_SEQ_CST
:
1630 pp_string (pp
, " seq_cst");
1632 case OMP_MEMORY_ORDER_ACQ_REL
:
1633 pp_string (pp
, " acq_rel");
1635 case OMP_MEMORY_ORDER_ACQUIRE
:
1636 pp_string (pp
, " acquire");
1638 case OMP_MEMORY_ORDER_RELEASE
:
1639 pp_string (pp
, " release");
1641 case OMP_MEMORY_ORDER_UNSPECIFIED
:
1646 switch (mo
& OMP_FAIL_MEMORY_ORDER_MASK
)
1648 case OMP_FAIL_MEMORY_ORDER_RELAXED
:
1649 pp_string (pp
, " fail(relaxed)");
1651 case OMP_FAIL_MEMORY_ORDER_SEQ_CST
:
1652 pp_string (pp
, " fail(seq_cst)");
1654 case OMP_FAIL_MEMORY_ORDER_ACQUIRE
:
1655 pp_string (pp
, " fail(acquire)");
1657 case OMP_FAIL_MEMORY_ORDER_UNSPECIFIED
:
1664 /* Helper to dump a MEM_REF node. */
1667 dump_mem_ref (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
)
1669 if (TREE_CODE (node
) == MEM_REF
&& (flags
& TDF_GIMPLE
))
1671 pp_string (pp
, "__MEM <");
1672 dump_generic_node (pp
, TREE_TYPE (node
),
1673 spc
, flags
| TDF_SLIM
, false);
1674 if (TYPE_ALIGN (TREE_TYPE (node
))
1675 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
1677 pp_string (pp
, ", ");
1678 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
1681 pp_string (pp
, " (");
1682 if (TREE_TYPE (TREE_OPERAND (node
, 0))
1683 != TREE_TYPE (TREE_OPERAND (node
, 1)))
1686 dump_generic_node (pp
, TREE_TYPE (TREE_OPERAND (node
, 1)),
1687 spc
, flags
| TDF_SLIM
, false);
1688 pp_right_paren (pp
);
1690 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1691 spc
, flags
| TDF_SLIM
, false);
1692 if (! integer_zerop (TREE_OPERAND (node
, 1)))
1694 pp_string (pp
, " + ");
1695 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1696 spc
, flags
| TDF_SLIM
, false);
1698 pp_right_paren (pp
);
1700 else if (TREE_CODE (node
) == MEM_REF
1701 && integer_zerop (TREE_OPERAND (node
, 1))
1702 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1703 infer them and MEM_ATTR caching will share MEM_REFs
1704 with differently-typed op0s. */
1705 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1706 /* Released SSA_NAMES have no TREE_TYPE. */
1707 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1708 /* Same pointer types, but ignoring POINTER_TYPE vs.
1710 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1711 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1712 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1713 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1714 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1715 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1716 /* Same value types ignoring qualifiers. */
1717 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1718 == TYPE_MAIN_VARIANT
1719 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1720 && (!(flags
& TDF_ALIAS
)
1721 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1723 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1725 /* Enclose pointers to arrays in parentheses. */
1726 tree op0
= TREE_OPERAND (node
, 0);
1727 tree op0type
= TREE_TYPE (op0
);
1728 if (POINTER_TYPE_P (op0type
)
1729 && TREE_CODE (TREE_TYPE (op0type
)) == ARRAY_TYPE
)
1732 dump_generic_node (pp
, op0
, spc
, flags
, false);
1733 if (POINTER_TYPE_P (op0type
)
1734 && TREE_CODE (TREE_TYPE (op0type
)) == ARRAY_TYPE
)
1735 pp_right_paren (pp
);
1738 dump_generic_node (pp
,
1739 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1744 pp_string (pp
, "MEM");
1746 tree nodetype
= TREE_TYPE (node
);
1747 tree op0
= TREE_OPERAND (node
, 0);
1748 tree op1
= TREE_OPERAND (node
, 1);
1749 tree op1type
= TYPE_MAIN_VARIANT (TREE_TYPE (op1
));
1751 tree op0size
= TYPE_SIZE (nodetype
);
1752 tree op1size
= TYPE_SIZE (TREE_TYPE (op1type
));
1754 if (!op0size
|| !op1size
1755 || !operand_equal_p (op0size
, op1size
, 0))
1757 pp_string (pp
, " <");
1758 /* If the size of the type of the operand is not the same
1759 as the size of the MEM_REF expression include the type
1760 of the latter similar to the TDF_GIMPLE output to make
1761 it clear how many bytes of memory are being accessed. */
1762 dump_generic_node (pp
, nodetype
, spc
, flags
| TDF_SLIM
, false);
1763 pp_string (pp
, "> ");
1766 pp_string (pp
, "[(");
1767 dump_generic_node (pp
, op1type
, spc
, flags
| TDF_SLIM
, false);
1768 pp_right_paren (pp
);
1769 dump_generic_node (pp
, op0
, spc
, flags
, false);
1770 if (!integer_zerop (op1
))
1772 pp_string (pp
, " + ");
1773 dump_generic_node (pp
, op1
, spc
, flags
, false);
1775 if (TREE_CODE (node
) == TARGET_MEM_REF
)
1777 tree tmp
= TMR_INDEX2 (node
);
1780 pp_string (pp
, " + ");
1781 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1783 tmp
= TMR_INDEX (node
);
1786 pp_string (pp
, " + ");
1787 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1788 tmp
= TMR_STEP (node
);
1789 pp_string (pp
, " * ");
1791 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1793 pp_string (pp
, "1");
1796 if ((flags
& TDF_ALIAS
)
1797 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1799 pp_string (pp
, " clique ");
1800 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1801 pp_string (pp
, " base ");
1802 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1804 pp_right_bracket (pp
);
1808 /* Helper function for dump_generic_node. Dump INIT or COND expression for
1809 OpenMP loop non-rectangular iterators. */
1812 dump_omp_loop_non_rect_expr (pretty_printer
*pp
, tree node
, int spc
,
1815 gcc_assert (TREE_CODE (node
) == TREE_VEC
);
1816 dump_generic_node (pp
, TREE_VEC_ELT (node
, 0), spc
, flags
, false);
1817 pp_string (pp
, " * ");
1818 if (op_prio (TREE_VEC_ELT (node
, 1)) <= op_code_prio (MULT_EXPR
))
1821 dump_generic_node (pp
, TREE_VEC_ELT (node
, 1), spc
, flags
, false);
1822 pp_right_paren (pp
);
1825 dump_generic_node (pp
, TREE_VEC_ELT (node
, 1), spc
, flags
, false);
1826 pp_string (pp
, " + ");
1827 if (op_prio (TREE_VEC_ELT (node
, 1)) <= op_code_prio (PLUS_EXPR
))
1830 dump_generic_node (pp
, TREE_VEC_ELT (node
, 2), spc
, flags
, false);
1831 pp_right_paren (pp
);
1834 dump_generic_node (pp
, TREE_VEC_ELT (node
, 2), spc
, flags
, false);
1837 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1838 indent. FLAGS specifies details to show in the dump (see TDF_* in
1839 dumpfile.h). If IS_STMT is true, the object printed is considered
1840 to be a statement and it is terminated by ';' if appropriate. */
1843 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
,
1850 enum tree_code code
;
1852 if (node
== NULL_TREE
)
1855 is_expr
= EXPR_P (node
);
1857 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1859 pp_string (pp
, "<&");
1860 pp_scalar (pp
, "%p", (void *)node
);
1861 pp_string (pp
, "> ");
1864 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1865 dump_location (pp
, EXPR_LOCATION (node
));
1867 code
= TREE_CODE (node
);
1871 pp_string (pp
, "<<< error >>>");
1874 case IDENTIFIER_NODE
:
1875 pp_tree_identifier (pp
, node
);
1879 while (node
&& node
!= error_mark_node
)
1881 if (TREE_PURPOSE (node
))
1883 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1886 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1887 node
= TREE_CHAIN (node
);
1888 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1897 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1903 if (TREE_VEC_LENGTH (node
) > 0)
1905 size_t len
= TREE_VEC_LENGTH (node
);
1906 for (i
= 0; i
< len
- 1; i
++)
1908 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1913 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1922 case FIXED_POINT_TYPE
:
1929 unsigned int quals
= TYPE_QUALS (node
);
1930 enum tree_code_class tclass
;
1932 if (quals
& TYPE_QUAL_ATOMIC
)
1933 pp_string (pp
, "atomic ");
1934 if (quals
& TYPE_QUAL_CONST
)
1935 pp_string (pp
, "const ");
1936 if (quals
& TYPE_QUAL_VOLATILE
)
1937 pp_string (pp
, "volatile ");
1938 if (quals
& TYPE_QUAL_RESTRICT
)
1939 pp_string (pp
, "restrict ");
1941 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1943 pp_string (pp
, "<address-space-");
1944 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1945 pp_string (pp
, "> ");
1948 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1950 if (tclass
== tcc_declaration
)
1952 if (DECL_NAME (node
))
1953 dump_decl_name (pp
, node
, flags
);
1955 pp_string (pp
, "<unnamed type decl>");
1957 else if (tclass
== tcc_type
)
1959 if (TYPE_NAME (node
))
1961 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1962 pp_tree_identifier (pp
, TYPE_NAME (node
));
1963 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1964 && DECL_NAME (TYPE_NAME (node
)))
1965 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1967 pp_string (pp
, "<unnamed type>");
1969 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1971 pp_string (pp
, "vector");
1973 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1974 pp_string (pp
, ") ");
1975 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1977 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1979 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1980 pp_string (pp
, (TYPE_UNSIGNED (node
)
1983 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1984 pp_string (pp
, (TYPE_UNSIGNED (node
)
1987 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1988 pp_string (pp
, (TYPE_UNSIGNED (node
)
1991 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1992 pp_string (pp
, (TYPE_UNSIGNED (node
)
1995 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1996 pp_string (pp
, (TYPE_UNSIGNED (node
)
1997 ? "unsigned long long"
1998 : "signed long long"));
1999 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
2000 && pow2p_hwi (TYPE_PRECISION (node
)))
2002 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
2003 pp_decimal_int (pp
, TYPE_PRECISION (node
));
2004 pp_string (pp
, "_t");
2008 pp_string (pp
, (TYPE_UNSIGNED (node
)
2009 ? "<unnamed-unsigned:"
2010 : "<unnamed-signed:"));
2011 pp_decimal_int (pp
, TYPE_PRECISION (node
));
2015 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
2017 pp_string (pp
, "__complex__ ");
2018 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2020 else if (TREE_CODE (node
) == REAL_TYPE
)
2022 pp_string (pp
, "<float:");
2023 pp_decimal_int (pp
, TYPE_PRECISION (node
));
2026 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
2028 pp_string (pp
, "<fixed-point-");
2029 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
2030 pp_decimal_int (pp
, TYPE_PRECISION (node
));
2033 else if (TREE_CODE (node
) == BOOLEAN_TYPE
)
2035 pp_string (pp
, (TYPE_UNSIGNED (node
)
2036 ? "<unsigned-boolean:"
2037 : "<signed-boolean:"));
2038 pp_decimal_int (pp
, TYPE_PRECISION (node
));
2041 else if (TREE_CODE (node
) == VOID_TYPE
)
2042 pp_string (pp
, "void");
2044 pp_string (pp
, "<unnamed type>");
2050 case REFERENCE_TYPE
:
2051 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
2053 if (TREE_TYPE (node
) == NULL
)
2055 pp_string (pp
, str
);
2056 pp_string (pp
, "<null type>");
2058 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
2060 tree fnode
= TREE_TYPE (node
);
2062 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
2065 pp_string (pp
, str
);
2066 if (TYPE_IDENTIFIER (node
))
2067 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
2068 else if (flags
& TDF_NOUID
)
2069 pp_string (pp
, "<Txxxx>");
2072 pp_string (pp
, "<T");
2073 pp_scalar (pp
, "%x", TYPE_UID (node
));
2074 pp_character (pp
, '>');
2077 pp_right_paren (pp
);
2078 dump_function_declaration (pp
, fnode
, spc
, flags
);
2082 unsigned int quals
= TYPE_QUALS (node
);
2084 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2086 pp_string (pp
, str
);
2088 if (quals
& TYPE_QUAL_CONST
)
2089 pp_string (pp
, " const");
2090 if (quals
& TYPE_QUAL_VOLATILE
)
2091 pp_string (pp
, " volatile");
2092 if (quals
& TYPE_QUAL_RESTRICT
)
2093 pp_string (pp
, " restrict");
2095 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
2097 pp_string (pp
, " <address-space-");
2098 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
2102 if (TYPE_REF_CAN_ALIAS_ALL (node
))
2103 pp_string (pp
, " {ref-all}");
2112 case TARGET_MEM_REF
:
2113 dump_mem_ref (pp
, node
, spc
, flags
);
2118 unsigned int quals
= TYPE_QUALS (node
);
2121 if (quals
& TYPE_QUAL_ATOMIC
)
2122 pp_string (pp
, "atomic ");
2123 if (quals
& TYPE_QUAL_CONST
)
2124 pp_string (pp
, "const ");
2125 if (quals
& TYPE_QUAL_VOLATILE
)
2126 pp_string (pp
, "volatile ");
2128 /* Print the innermost component type. */
2129 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
2130 tmp
= TREE_TYPE (tmp
))
2133 /* Avoid to print recursively the array. */
2134 /* FIXME : Not implemented correctly, see print_struct_decl. */
2135 if (TREE_CODE (tmp
) != POINTER_TYPE
|| TREE_TYPE (tmp
) != node
)
2136 dump_generic_node (pp
, tmp
, spc
, flags
, false);
2138 /* Print the dimensions. */
2139 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
2140 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
2146 case QUAL_UNION_TYPE
:
2148 unsigned int quals
= TYPE_QUALS (node
);
2150 if (quals
& TYPE_QUAL_ATOMIC
)
2151 pp_string (pp
, "atomic ");
2152 if (quals
& TYPE_QUAL_CONST
)
2153 pp_string (pp
, "const ");
2154 if (quals
& TYPE_QUAL_VOLATILE
)
2155 pp_string (pp
, "volatile ");
2157 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
2159 pp_string (pp
, "<address-space-");
2160 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
2161 pp_string (pp
, "> ");
2164 /* Print the name of the structure. */
2165 if (TREE_CODE (node
) == RECORD_TYPE
)
2166 pp_string (pp
, "struct ");
2167 else if (TREE_CODE (node
) == UNION_TYPE
)
2168 pp_string (pp
, "union ");
2170 if (TYPE_NAME (node
))
2171 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
2172 else if (!(flags
& TDF_SLIM
))
2173 /* FIXME: If we eliminate the 'else' above and attempt
2174 to show the fields for named types, we may get stuck
2175 following a cycle of pointers to structs. The alleged
2176 self-reference check in print_struct_decl will not detect
2177 cycles involving more than one pointer or struct type. */
2178 print_struct_decl (pp
, node
, spc
, flags
);
2187 if (flags
& TDF_GIMPLE
2188 && (POINTER_TYPE_P (TREE_TYPE (node
))
2189 || (TYPE_PRECISION (TREE_TYPE (node
))
2190 < TYPE_PRECISION (integer_type_node
))
2191 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1
2192 || tree_int_cst_sgn (node
) < 0))
2194 pp_string (pp
, "_Literal (");
2195 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2196 pp_string (pp
, ") ");
2198 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
2199 && ! (flags
& TDF_GIMPLE
))
2201 /* In the case of a pointer, one may want to divide by the
2202 size of the pointed-to type. Unfortunately, this not
2203 straightforward. The C front-end maps expressions
2208 in such a way that the two INTEGER_CST nodes for "5" have
2209 different values but identical types. In the latter
2210 case, the 5 is multiplied by sizeof (int) in c-common.cc
2211 (pointer_int_sum) to convert it to a byte address, and
2212 yet the type of the node is left unchanged. Argh. What
2213 is consistent though is that the number value corresponds
2214 to bytes (UNITS) offset.
2216 NB: Neither of the following divisors can be trivially
2217 used to recover the original literal:
2219 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
2220 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
2221 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
2222 pp_string (pp
, "B"); /* pseudo-unit */
2224 else if (tree_fits_shwi_p (node
))
2225 pp_wide_integer (pp
, tree_to_shwi (node
));
2226 else if (tree_fits_uhwi_p (node
))
2227 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
2230 wide_int val
= wi::to_wide (node
);
2232 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
2237 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
2238 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
2240 if ((flags
& TDF_GIMPLE
)
2241 && ! (POINTER_TYPE_P (TREE_TYPE (node
))
2242 || (TYPE_PRECISION (TREE_TYPE (node
))
2243 < TYPE_PRECISION (integer_type_node
))
2244 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
2246 if (TYPE_UNSIGNED (TREE_TYPE (node
)))
2247 pp_character (pp
, 'u');
2248 if (TYPE_PRECISION (TREE_TYPE (node
))
2249 == TYPE_PRECISION (unsigned_type_node
))
2251 else if (TYPE_PRECISION (TREE_TYPE (node
))
2252 == TYPE_PRECISION (long_unsigned_type_node
))
2253 pp_character (pp
, 'l');
2254 else if (TYPE_PRECISION (TREE_TYPE (node
))
2255 == TYPE_PRECISION (long_long_unsigned_type_node
))
2256 pp_string (pp
, "ll");
2258 if (TREE_OVERFLOW (node
))
2259 pp_string (pp
, "(OVF)");
2263 pp_string (pp
, "POLY_INT_CST [");
2264 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, 0), spc
, flags
, false);
2265 for (unsigned int i
= 1; i
< NUM_POLY_INT_COEFFS
; ++i
)
2267 pp_string (pp
, ", ");
2268 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, i
),
2271 pp_string (pp
, "]");
2275 /* Code copied from print_node. */
2278 if (TREE_OVERFLOW (node
))
2279 pp_string (pp
, " overflow");
2281 d
= TREE_REAL_CST (node
);
2282 if (REAL_VALUE_ISINF (d
))
2283 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
2284 else if (REAL_VALUE_ISNAN (d
))
2285 pp_string (pp
, " Nan");
2289 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
2290 pp_string (pp
, string
);
2298 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
2299 pp_string (pp
, string
);
2304 pp_string (pp
, "__complex__ (");
2305 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
2306 pp_string (pp
, ", ");
2307 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
2308 pp_right_paren (pp
);
2313 pp_string (pp
, "\"");
2314 if (unsigned nbytes
= TREE_STRING_LENGTH (node
))
2315 pretty_print_string (pp
, TREE_STRING_POINTER (node
), nbytes
);
2316 pp_string (pp
, "\"");
2323 if (flags
& TDF_GIMPLE
)
2325 pp_string (pp
, "_Literal (");
2326 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2327 pp_string (pp
, ") ");
2329 pp_string (pp
, "{ ");
2330 unsigned HOST_WIDE_INT nunits
;
2331 if (!VECTOR_CST_NELTS (node
).is_constant (&nunits
))
2332 nunits
= vector_cst_encoded_nelts (node
);
2333 for (i
= 0; i
< nunits
; ++i
)
2336 pp_string (pp
, ", ");
2337 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
2340 if (!VECTOR_CST_NELTS (node
).is_constant ())
2341 pp_string (pp
, ", ...");
2342 pp_string (pp
, " }");
2348 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2350 if (TREE_CODE (node
) == METHOD_TYPE
)
2352 if (TYPE_METHOD_BASETYPE (node
))
2353 dump_generic_node (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
2356 pp_string (pp
, "<null method basetype>");
2357 pp_colon_colon (pp
);
2359 if (TYPE_IDENTIFIER (node
))
2360 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
2361 else if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
2362 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
2363 else if (flags
& TDF_NOUID
)
2364 pp_string (pp
, "<Txxxx>");
2367 pp_string (pp
, "<T");
2368 pp_scalar (pp
, "%x", TYPE_UID (node
));
2369 pp_character (pp
, '>');
2371 dump_function_declaration (pp
, node
, spc
, flags
);
2376 dump_decl_name (pp
, node
, flags
);
2380 if (DECL_NAME (node
))
2381 dump_decl_name (pp
, node
, flags
);
2382 else if (LABEL_DECL_UID (node
) != -1)
2384 if (flags
& TDF_GIMPLE
)
2386 pp_character (pp
, 'L');
2387 pp_decimal_int (pp
, (int) LABEL_DECL_UID (node
));
2391 pp_string (pp
, "<L");
2392 pp_decimal_int (pp
, (int) LABEL_DECL_UID (node
));
2393 pp_character (pp
, '>');
2398 if (flags
& TDF_NOUID
)
2399 pp_string (pp
, "<D.xxxx>");
2402 if (flags
& TDF_GIMPLE
)
2404 pp_character (pp
, 'D');
2405 pp_scalar (pp
, "%u", DECL_UID (node
));
2409 pp_string (pp
, "<D.");
2410 pp_scalar (pp
, "%u", DECL_UID (node
));
2411 pp_character (pp
, '>');
2418 if (DECL_IS_UNDECLARED_BUILTIN (node
))
2420 /* Don't print the declaration of built-in types. */
2423 if (DECL_NAME (node
))
2424 dump_decl_name (pp
, node
, flags
);
2425 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
2427 pp_string (pp
, (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
2428 ? "union" : "struct "));
2429 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2432 pp_string (pp
, "<anon>");
2438 case DEBUG_EXPR_DECL
:
2439 case NAMESPACE_DECL
:
2441 dump_decl_name (pp
, node
, flags
);
2445 pp_string (pp
, "<retval>");
2449 op0
= TREE_OPERAND (node
, 0);
2452 && (TREE_CODE (op0
) == INDIRECT_REF
2453 || (TREE_CODE (op0
) == MEM_REF
2454 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
2455 && integer_zerop (TREE_OPERAND (op0
, 1))
2456 /* Dump the types of INTEGER_CSTs explicitly, for we
2457 can't infer them and MEM_ATTR caching will share
2458 MEM_REFs with differently-typed op0s. */
2459 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
2460 /* Released SSA_NAMES have no TREE_TYPE. */
2461 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
2462 /* Same pointer types, but ignoring POINTER_TYPE vs.
2464 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2465 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2466 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2467 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2468 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2469 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
2470 /* Same value types ignoring qualifiers. */
2471 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
2472 == TYPE_MAIN_VARIANT
2473 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
2474 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
2476 op0
= TREE_OPERAND (op0
, 0);
2479 if (op_prio (op0
) < op_prio (node
))
2481 dump_generic_node (pp
, op0
, spc
, flags
, false);
2482 if (op_prio (op0
) < op_prio (node
))
2483 pp_right_paren (pp
);
2484 pp_string (pp
, str
);
2485 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2486 op0
= component_ref_field_offset (node
);
2487 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
2489 pp_string (pp
, "{off: ");
2490 dump_generic_node (pp
, op0
, spc
, flags
, false);
2491 pp_right_brace (pp
);
2496 if (flags
& TDF_GIMPLE
)
2498 pp_string (pp
, "__BIT_FIELD_REF <");
2499 dump_generic_node (pp
, TREE_TYPE (node
),
2500 spc
, flags
| TDF_SLIM
, false);
2501 if (TYPE_ALIGN (TREE_TYPE (node
))
2502 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
2504 pp_string (pp
, ", ");
2505 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
2508 pp_string (pp
, " (");
2509 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
,
2510 flags
| TDF_SLIM
, false);
2511 pp_string (pp
, ", ");
2512 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
,
2513 flags
| TDF_SLIM
, false);
2514 pp_string (pp
, ", ");
2515 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
,
2516 flags
| TDF_SLIM
, false);
2517 pp_right_paren (pp
);
2521 pp_string (pp
, "BIT_FIELD_REF <");
2522 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2523 pp_string (pp
, ", ");
2524 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2525 pp_string (pp
, ", ");
2526 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2531 case BIT_INSERT_EXPR
:
2532 pp_string (pp
, "BIT_INSERT_EXPR <");
2533 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2534 pp_string (pp
, ", ");
2535 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2536 pp_string (pp
, ", ");
2537 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2538 pp_string (pp
, " (");
2539 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
2541 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
2543 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
2545 pp_string (pp
, " bits)>");
2549 case ARRAY_RANGE_REF
:
2550 op0
= TREE_OPERAND (node
, 0);
2551 if (op_prio (op0
) < op_prio (node
))
2553 dump_generic_node (pp
, op0
, spc
, flags
, false);
2554 if (op_prio (op0
) < op_prio (node
))
2555 pp_right_paren (pp
);
2556 pp_left_bracket (pp
);
2557 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2558 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
2559 pp_string (pp
, " ...");
2560 pp_right_bracket (pp
);
2562 op0
= array_ref_low_bound (node
);
2563 op1
= array_ref_element_size (node
);
2565 if (!integer_zerop (op0
)
2566 || TREE_OPERAND (node
, 2)
2567 || TREE_OPERAND (node
, 3))
2569 pp_string (pp
, "{lb: ");
2570 dump_generic_node (pp
, op0
, spc
, flags
, false);
2571 pp_string (pp
, " sz: ");
2572 dump_generic_node (pp
, op1
, spc
, flags
, false);
2573 pp_right_brace (pp
);
2579 unsigned HOST_WIDE_INT ix
;
2581 bool is_struct_init
= false;
2582 bool is_array_init
= false;
2584 if (flags
& TDF_GIMPLE
)
2586 pp_string (pp
, "_Literal (");
2587 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2588 pp_string (pp
, ") ");
2591 if (TREE_CLOBBER_P (node
))
2593 pp_string (pp
, "CLOBBER");
2594 if (CLOBBER_KIND (node
) == CLOBBER_EOL
)
2595 pp_string (pp
, "(eol)");
2597 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
2598 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
2599 is_struct_init
= true;
2600 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
2601 && TYPE_DOMAIN (TREE_TYPE (node
))
2602 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
2603 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
2606 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
2607 is_array_init
= true;
2608 curidx
= wi::to_widest (minv
);
2610 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
2617 dump_generic_node (pp
, field
, spc
, flags
, false);
2620 else if (is_array_init
2621 && (TREE_CODE (field
) != INTEGER_CST
2622 || curidx
!= wi::to_widest (field
)))
2624 pp_left_bracket (pp
);
2625 if (TREE_CODE (field
) == RANGE_EXPR
)
2627 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
2629 pp_string (pp
, " ... ");
2630 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
2632 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
2633 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
2636 dump_generic_node (pp
, field
, spc
, flags
, false);
2637 if (TREE_CODE (field
) == INTEGER_CST
)
2638 curidx
= wi::to_widest (field
);
2639 pp_string (pp
, "]=");
2644 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
2645 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
2646 val
= TREE_OPERAND (val
, 0);
2647 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
2648 dump_decl_name (pp
, val
, flags
);
2650 dump_generic_node (pp
, val
, spc
, flags
, false);
2651 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2657 pp_right_brace (pp
);
2664 if (flags
& TDF_SLIM
)
2666 pp_string (pp
, "<COMPOUND_EXPR>");
2670 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2671 spc
, flags
, !(flags
& TDF_SLIM
));
2672 if (flags
& TDF_SLIM
)
2673 newline_and_indent (pp
, spc
);
2680 for (tp
= &TREE_OPERAND (node
, 1);
2681 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2682 tp
= &TREE_OPERAND (*tp
, 1))
2684 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2685 spc
, flags
, !(flags
& TDF_SLIM
));
2686 if (flags
& TDF_SLIM
)
2687 newline_and_indent (pp
, spc
);
2695 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2699 case STATEMENT_LIST
:
2701 tree_stmt_iterator si
;
2704 if (flags
& TDF_SLIM
)
2706 pp_string (pp
, "<STATEMENT_LIST>");
2710 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2713 newline_and_indent (pp
, spc
);
2716 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2723 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2728 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2733 pp_string (pp
, "TARGET_EXPR <");
2734 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2737 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2742 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2747 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2749 pp_string (pp
, "if (");
2750 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2751 pp_right_paren (pp
);
2752 /* The lowered cond_exprs should always be printed in full. */
2753 if (COND_EXPR_THEN (node
)
2754 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2755 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2756 && COND_EXPR_ELSE (node
)
2757 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2758 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2761 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2763 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2765 pp_string (pp
, " else ");
2766 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2770 else if (!(flags
& TDF_SLIM
))
2772 /* Output COND_EXPR_THEN. */
2773 if (COND_EXPR_THEN (node
))
2775 newline_and_indent (pp
, spc
+2);
2777 newline_and_indent (pp
, spc
+4);
2778 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2780 newline_and_indent (pp
, spc
+2);
2781 pp_right_brace (pp
);
2784 /* Output COND_EXPR_ELSE. */
2785 if (COND_EXPR_ELSE (node
)
2786 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2788 newline_and_indent (pp
, spc
);
2789 pp_string (pp
, "else");
2790 newline_and_indent (pp
, spc
+2);
2792 newline_and_indent (pp
, spc
+4);
2793 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2795 newline_and_indent (pp
, spc
+2);
2796 pp_right_brace (pp
);
2803 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2807 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2811 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2817 if (!(flags
& TDF_SLIM
))
2819 if (BIND_EXPR_VARS (node
))
2823 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2825 print_declaration (pp
, op0
, spc
+2, flags
);
2830 newline_and_indent (pp
, spc
+2);
2831 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2832 newline_and_indent (pp
, spc
);
2833 pp_right_brace (pp
);
2839 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2840 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2844 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2847 /* Print parameters. */
2852 call_expr_arg_iterator iter
;
2853 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2855 dump_generic_node (pp
, arg
, spc
, flags
, false);
2856 if (more_call_expr_args_p (&iter
))
2863 if (CALL_EXPR_VA_ARG_PACK (node
))
2865 if (call_expr_nargs (node
) > 0)
2870 pp_string (pp
, "__builtin_va_arg_pack ()");
2872 pp_right_paren (pp
);
2874 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2877 pp_string (pp
, " [static-chain: ");
2878 dump_generic_node (pp
, op1
, spc
, flags
, false);
2879 pp_right_bracket (pp
);
2882 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2883 pp_string (pp
, " [return slot optimization]");
2884 if (CALL_EXPR_TAILCALL (node
))
2885 pp_string (pp
, " [tail call]");
2888 case WITH_CLEANUP_EXPR
:
2892 case CLEANUP_POINT_EXPR
:
2893 pp_string (pp
, "<<cleanup_point ");
2894 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2895 pp_string (pp
, ">>");
2898 case PLACEHOLDER_EXPR
:
2899 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2900 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2904 /* Binary arithmetic and logic expressions. */
2905 case WIDEN_SUM_EXPR
:
2906 case WIDEN_MULT_EXPR
:
2908 case MULT_HIGHPART_EXPR
:
2910 case POINTER_PLUS_EXPR
:
2911 case POINTER_DIFF_EXPR
:
2913 case TRUNC_DIV_EXPR
:
2915 case FLOOR_DIV_EXPR
:
2916 case ROUND_DIV_EXPR
:
2917 case TRUNC_MOD_EXPR
:
2919 case FLOOR_MOD_EXPR
:
2920 case ROUND_MOD_EXPR
:
2922 case EXACT_DIV_EXPR
:
2927 case WIDEN_LSHIFT_EXPR
:
2931 case TRUTH_ANDIF_EXPR
:
2932 case TRUTH_ORIF_EXPR
:
2933 case TRUTH_AND_EXPR
:
2935 case TRUTH_XOR_EXPR
:
2949 case UNORDERED_EXPR
:
2951 const char *op
= op_symbol (node
);
2952 op0
= TREE_OPERAND (node
, 0);
2953 op1
= TREE_OPERAND (node
, 1);
2955 /* When the operands are expressions with less priority,
2956 keep semantics of the tree representation. */
2957 if (op_prio (op0
) <= op_prio (node
))
2960 dump_generic_node (pp
, op0
, spc
, flags
, false);
2961 pp_right_paren (pp
);
2964 dump_generic_node (pp
, op0
, spc
, flags
, false);
2970 /* When the operands are expressions with less priority,
2971 keep semantics of the tree representation. */
2972 if (op_prio (op1
) <= op_prio (node
))
2975 dump_generic_node (pp
, op1
, spc
, flags
, false);
2976 pp_right_paren (pp
);
2979 dump_generic_node (pp
, op1
, spc
, flags
, false);
2983 /* Unary arithmetic and logic expressions. */
2985 if (flags
& TDF_GIMPLE_VAL
)
2987 pp_string (pp
, "_Literal (");
2988 dump_generic_node (pp
, TREE_TYPE (node
), spc
,
2989 flags
& ~TDF_GIMPLE_VAL
, false);
2990 pp_character (pp
, ')');
2995 case TRUTH_NOT_EXPR
:
2996 case PREDECREMENT_EXPR
:
2997 case PREINCREMENT_EXPR
:
2999 if (!(flags
& TDF_GIMPLE
)
3000 && TREE_CODE (node
) == ADDR_EXPR
3001 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
3002 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
3003 /* Do not output '&' for strings and function pointers when not
3004 dumping GIMPLE FE syntax. */
3007 pp_string (pp
, op_symbol (node
));
3009 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
3012 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3013 pp_right_paren (pp
);
3016 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3019 case POSTDECREMENT_EXPR
:
3020 case POSTINCREMENT_EXPR
:
3021 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
3024 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3025 pp_right_paren (pp
);
3028 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3029 pp_string (pp
, op_symbol (node
));
3033 pp_string (pp
, "MIN_EXPR <");
3034 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3035 pp_string (pp
, ", ");
3036 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3041 pp_string (pp
, "MAX_EXPR <");
3042 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3043 pp_string (pp
, ", ");
3044 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3049 pp_string (pp
, "ABS_EXPR <");
3050 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3055 pp_string (pp
, "ABSU_EXPR <");
3056 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3064 case ADDR_SPACE_CONVERT_EXPR
:
3065 case FIXED_CONVERT_EXPR
:
3066 case FIX_TRUNC_EXPR
:
3069 type
= TREE_TYPE (node
);
3070 op0
= TREE_OPERAND (node
, 0);
3071 if (type
!= TREE_TYPE (op0
))
3074 dump_generic_node (pp
, type
, spc
, flags
, false);
3075 pp_string (pp
, ") ");
3077 if (op_prio (op0
) < op_prio (node
))
3079 dump_generic_node (pp
, op0
, spc
, flags
, false);
3080 if (op_prio (op0
) < op_prio (node
))
3081 pp_right_paren (pp
);
3084 case VIEW_CONVERT_EXPR
:
3085 if (flags
& TDF_GIMPLE
)
3086 pp_string (pp
, "__VIEW_CONVERT <");
3088 pp_string (pp
, "VIEW_CONVERT_EXPR<");
3089 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
3090 pp_string (pp
, ">(");
3091 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3092 pp_right_paren (pp
);
3096 pp_string (pp
, "((");
3097 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3098 pp_string (pp
, "))");
3101 case NON_LVALUE_EXPR
:
3102 pp_string (pp
, "NON_LVALUE_EXPR <");
3103 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3108 pp_string (pp
, "SAVE_EXPR <");
3109 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3114 pp_string (pp
, "COMPLEX_EXPR <");
3115 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3116 pp_string (pp
, ", ");
3117 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3122 pp_string (pp
, "CONJ_EXPR <");
3123 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3128 if (flags
& TDF_GIMPLE
)
3130 pp_string (pp
, "__real ");
3131 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3135 pp_string (pp
, "REALPART_EXPR <");
3136 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3142 if (flags
& TDF_GIMPLE
)
3144 pp_string (pp
, "__imag ");
3145 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3149 pp_string (pp
, "IMAGPART_EXPR <");
3150 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3156 pp_string (pp
, "VA_ARG_EXPR <");
3157 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3161 case TRY_FINALLY_EXPR
:
3162 case TRY_CATCH_EXPR
:
3163 pp_string (pp
, "try");
3164 newline_and_indent (pp
, spc
+2);
3166 newline_and_indent (pp
, spc
+4);
3167 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
3168 newline_and_indent (pp
, spc
+2);
3169 pp_right_brace (pp
);
3170 newline_and_indent (pp
, spc
);
3171 if (TREE_CODE (node
) == TRY_CATCH_EXPR
)
3173 node
= TREE_OPERAND (node
, 1);
3174 pp_string (pp
, "catch");
3178 gcc_assert (TREE_CODE (node
) == TRY_FINALLY_EXPR
);
3179 node
= TREE_OPERAND (node
, 1);
3180 pp_string (pp
, "finally");
3181 if (TREE_CODE (node
) == EH_ELSE_EXPR
)
3183 newline_and_indent (pp
, spc
+2);
3185 newline_and_indent (pp
, spc
+4);
3186 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4,
3188 newline_and_indent (pp
, spc
+2);
3189 pp_right_brace (pp
);
3190 newline_and_indent (pp
, spc
);
3191 node
= TREE_OPERAND (node
, 1);
3192 pp_string (pp
, "else");
3195 newline_and_indent (pp
, spc
+2);
3197 newline_and_indent (pp
, spc
+4);
3198 dump_generic_node (pp
, node
, spc
+4, flags
, true);
3199 newline_and_indent (pp
, spc
+2);
3200 pp_right_brace (pp
);
3205 pp_string (pp
, "catch (");
3206 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
3207 pp_right_paren (pp
);
3208 newline_and_indent (pp
, spc
+2);
3210 newline_and_indent (pp
, spc
+4);
3211 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
3212 newline_and_indent (pp
, spc
+2);
3213 pp_right_brace (pp
);
3217 case EH_FILTER_EXPR
:
3218 pp_string (pp
, "<<<eh_filter (");
3219 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
3220 pp_string (pp
, ")>>>");
3221 newline_and_indent (pp
, spc
+2);
3223 newline_and_indent (pp
, spc
+4);
3224 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
3225 newline_and_indent (pp
, spc
+2);
3226 pp_right_brace (pp
);
3231 op0
= TREE_OPERAND (node
, 0);
3232 /* If this is for break or continue, don't bother printing it. */
3233 if (DECL_NAME (op0
))
3235 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
3236 if (strcmp (name
, "break") == 0
3237 || strcmp (name
, "continue") == 0)
3240 dump_generic_node (pp
, op0
, spc
, flags
, false);
3242 if (DECL_NONLOCAL (op0
))
3243 pp_string (pp
, " [non-local]");
3247 pp_string (pp
, "while (1)");
3248 if (!(flags
& TDF_SLIM
))
3250 newline_and_indent (pp
, spc
+2);
3252 newline_and_indent (pp
, spc
+4);
3253 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
3254 newline_and_indent (pp
, spc
+2);
3255 pp_right_brace (pp
);
3261 pp_string (pp
, "// predicted ");
3262 if (PREDICT_EXPR_OUTCOME (node
))
3263 pp_string (pp
, "likely by ");
3265 pp_string (pp
, "unlikely by ");
3266 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
3267 pp_string (pp
, " predictor.");
3271 pp_string (pp
, "ANNOTATE_EXPR <");
3272 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3273 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
3275 case annot_expr_ivdep_kind
:
3276 pp_string (pp
, ", ivdep");
3278 case annot_expr_unroll_kind
:
3280 pp_string (pp
, ", unroll ");
3282 (int) TREE_INT_CST_LOW (TREE_OPERAND (node
, 2)));
3285 case annot_expr_no_vector_kind
:
3286 pp_string (pp
, ", no-vector");
3288 case annot_expr_vector_kind
:
3289 pp_string (pp
, ", vector");
3291 case annot_expr_parallel_kind
:
3292 pp_string (pp
, ", parallel");
3301 pp_string (pp
, "return");
3302 op0
= TREE_OPERAND (node
, 0);
3306 if (TREE_CODE (op0
) == MODIFY_EXPR
)
3307 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
3310 dump_generic_node (pp
, op0
, spc
, flags
, false);
3315 pp_string (pp
, "if (");
3316 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3317 pp_string (pp
, ") break");
3321 pp_string (pp
, "switch (");
3322 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
3323 pp_right_paren (pp
);
3324 if (!(flags
& TDF_SLIM
))
3326 newline_and_indent (pp
, spc
+2);
3328 if (SWITCH_BODY (node
))
3330 newline_and_indent (pp
, spc
+4);
3331 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
3334 newline_and_indent (pp
, spc
+2);
3335 pp_right_brace (pp
);
3341 op0
= GOTO_DESTINATION (node
);
3342 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
3344 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
3345 if (strcmp (name
, "break") == 0
3346 || strcmp (name
, "continue") == 0)
3348 pp_string (pp
, name
);
3352 pp_string (pp
, "goto ");
3353 dump_generic_node (pp
, op0
, spc
, flags
, false);
3357 pp_string (pp
, "__asm__");
3358 if (ASM_VOLATILE_P (node
))
3359 pp_string (pp
, " __volatile__");
3361 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
3363 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
3365 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
3366 if (ASM_CLOBBERS (node
))
3369 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
3371 pp_right_paren (pp
);
3374 case CASE_LABEL_EXPR
:
3375 if (CASE_LOW (node
) && CASE_HIGH (node
))
3377 pp_string (pp
, "case ");
3378 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
3379 pp_string (pp
, " ... ");
3380 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
3382 else if (CASE_LOW (node
))
3384 pp_string (pp
, "case ");
3385 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
3388 pp_string (pp
, "default");
3393 pp_string (pp
, "OBJ_TYPE_REF(");
3394 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
3396 /* We omit the class type for -fcompare-debug because we may
3397 drop TYPE_BINFO early depending on debug info, and then
3398 virtual_method_call_p would return false, whereas when
3399 TYPE_BINFO is preserved it may still return true and then
3400 we'd print the class type. Compare tree and rtl dumps for
3401 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
3402 for example, at occurrences of OBJ_TYPE_REF. */
3403 if (!(flags
& (TDF_SLIM
| TDF_COMPARE_DEBUG
))
3404 && virtual_method_call_p (node
, true))
3406 pp_string (pp
, "(");
3407 dump_generic_node (pp
, obj_type_ref_class (node
, true),
3409 pp_string (pp
, ")");
3411 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
3413 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
3414 pp_right_paren (pp
);
3418 if (SSA_NAME_IDENTIFIER (node
))
3420 if ((flags
& TDF_NOUID
)
3421 && SSA_NAME_VAR (node
)
3422 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
3423 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
3424 else if (! (flags
& TDF_GIMPLE
)
3425 || SSA_NAME_VAR (node
))
3426 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
3430 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
3431 if (SSA_NAME_IS_DEFAULT_DEF (node
))
3432 pp_string (pp
, "(D)");
3433 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
3434 pp_string (pp
, "(ab)");
3437 case WITH_SIZE_EXPR
:
3438 pp_string (pp
, "WITH_SIZE_EXPR <");
3439 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3440 pp_string (pp
, ", ");
3441 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3446 pp_string (pp
, "scev_known");
3449 case SCEV_NOT_KNOWN
:
3450 pp_string (pp
, "scev_not_known");
3453 case POLYNOMIAL_CHREC
:
3455 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
3456 pp_string (pp
, ", +, ");
3457 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
3458 pp_string (pp
, "}_");
3459 pp_scalar (pp
, "%u", CHREC_VARIABLE (node
));
3463 case REALIGN_LOAD_EXPR
:
3464 pp_string (pp
, "REALIGN_LOAD <");
3465 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3466 pp_string (pp
, ", ");
3467 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3468 pp_string (pp
, ", ");
3469 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3474 pp_string (pp
, " VEC_COND_EXPR < ");
3475 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3476 pp_string (pp
, " , ");
3477 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3478 pp_string (pp
, " , ");
3479 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3480 pp_string (pp
, " > ");
3484 pp_string (pp
, " VEC_PERM_EXPR < ");
3485 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3486 pp_string (pp
, " , ");
3487 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3488 pp_string (pp
, " , ");
3489 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3490 pp_string (pp
, " > ");
3494 pp_string (pp
, " DOT_PROD_EXPR < ");
3495 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3496 pp_string (pp
, ", ");
3497 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3498 pp_string (pp
, ", ");
3499 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3500 pp_string (pp
, " > ");
3503 case WIDEN_MULT_PLUS_EXPR
:
3504 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
3505 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3506 pp_string (pp
, ", ");
3507 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3508 pp_string (pp
, ", ");
3509 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3510 pp_string (pp
, " > ");
3513 case WIDEN_MULT_MINUS_EXPR
:
3514 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
3515 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3516 pp_string (pp
, ", ");
3517 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3518 pp_string (pp
, ", ");
3519 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
3520 pp_string (pp
, " > ");
3524 pp_string (pp
, "#pragma acc parallel");
3525 goto dump_omp_clauses_body
;
3528 pp_string (pp
, "#pragma acc kernels");
3529 goto dump_omp_clauses_body
;
3532 pp_string (pp
, "#pragma acc serial");
3533 goto dump_omp_clauses_body
;
3536 pp_string (pp
, "#pragma acc data");
3537 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
3540 case OACC_HOST_DATA
:
3541 pp_string (pp
, "#pragma acc host_data");
3542 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
3546 pp_string (pp
, "#pragma acc declare");
3547 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
3551 pp_string (pp
, "#pragma acc update");
3552 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
3555 case OACC_ENTER_DATA
:
3556 pp_string (pp
, "#pragma acc enter data");
3557 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3560 case OACC_EXIT_DATA
:
3561 pp_string (pp
, "#pragma acc exit data");
3562 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3566 pp_string (pp
, "#pragma acc cache");
3567 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
3571 pp_string (pp
, "#pragma omp parallel");
3572 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
3575 dump_omp_clauses_body
:
3576 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
3580 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
3582 newline_and_indent (pp
, spc
+ 2);
3584 newline_and_indent (pp
, spc
+ 4);
3585 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
3586 newline_and_indent (pp
, spc
+ 2);
3587 pp_right_brace (pp
);
3593 pp_string (pp
, OMP_TASK_BODY (node
) ? "#pragma omp task"
3594 : "#pragma omp taskwait");
3595 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
3599 pp_string (pp
, "#pragma omp for");
3603 pp_string (pp
, "#pragma omp simd");
3606 case OMP_DISTRIBUTE
:
3607 pp_string (pp
, "#pragma omp distribute");
3611 pp_string (pp
, "#pragma omp taskloop");
3615 pp_string (pp
, "#pragma omp loop");
3619 pp_string (pp
, "#pragma acc loop");
3623 pp_string (pp
, "#pragma omp teams");
3624 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
3627 case OMP_TARGET_DATA
:
3628 pp_string (pp
, "#pragma omp target data");
3629 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
3632 case OMP_TARGET_ENTER_DATA
:
3633 pp_string (pp
, "#pragma omp target enter data");
3634 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3638 case OMP_TARGET_EXIT_DATA
:
3639 pp_string (pp
, "#pragma omp target exit data");
3640 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3645 pp_string (pp
, "#pragma omp target");
3646 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3649 case OMP_TARGET_UPDATE
:
3650 pp_string (pp
, "#pragma omp target update");
3651 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3656 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3657 if (!(flags
& TDF_SLIM
))
3661 if (OMP_FOR_PRE_BODY (node
))
3663 newline_and_indent (pp
, spc
+ 2);
3666 newline_and_indent (pp
, spc
);
3667 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3670 if (OMP_FOR_INIT (node
))
3673 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3676 newline_and_indent (pp
, spc
);
3677 pp_string (pp
, "for (");
3678 tree init
= TREE_VEC_ELT (OMP_FOR_INIT (node
), i
);
3679 if (TREE_CODE (init
) != MODIFY_EXPR
3680 || TREE_CODE (TREE_OPERAND (init
, 1)) != TREE_VEC
)
3681 dump_generic_node (pp
, init
, spc
, flags
, false);
3684 dump_generic_node (pp
, TREE_OPERAND (init
, 0),
3686 pp_string (pp
, " = ");
3687 dump_omp_loop_non_rect_expr (pp
, TREE_OPERAND (init
, 1),
3690 pp_string (pp
, "; ");
3691 tree cond
= TREE_VEC_ELT (OMP_FOR_COND (node
), i
);
3692 if (!COMPARISON_CLASS_P (cond
)
3693 || TREE_CODE (TREE_OPERAND (cond
, 1)) != TREE_VEC
)
3694 dump_generic_node (pp
, cond
, spc
, flags
, false);
3697 dump_generic_node (pp
, TREE_OPERAND (cond
, 0),
3699 const char *op
= op_symbol (cond
);
3703 dump_omp_loop_non_rect_expr (pp
, TREE_OPERAND (cond
, 1),
3706 pp_string (pp
, "; ");
3707 dump_generic_node (pp
,
3708 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3710 pp_right_paren (pp
);
3713 if (OMP_FOR_BODY (node
))
3715 newline_and_indent (pp
, spc
+ 2);
3717 newline_and_indent (pp
, spc
+ 4);
3718 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3720 newline_and_indent (pp
, spc
+ 2);
3721 pp_right_brace (pp
);
3723 if (OMP_FOR_INIT (node
))
3724 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3725 if (OMP_FOR_PRE_BODY (node
))
3728 newline_and_indent (pp
, spc
+ 2);
3729 pp_right_brace (pp
);
3736 pp_string (pp
, "#pragma omp sections");
3737 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3741 pp_string (pp
, "#pragma omp section");
3745 if (OMP_SCAN_CLAUSES (node
))
3747 pp_string (pp
, "#pragma omp scan");
3748 dump_omp_clauses (pp
, OMP_SCAN_CLAUSES (node
), spc
, flags
);
3753 pp_string (pp
, "#pragma omp master");
3757 pp_string (pp
, "#pragma omp masked");
3758 dump_omp_clauses (pp
, OMP_MASKED_CLAUSES (node
), spc
, flags
);
3762 pp_string (pp
, "#pragma omp taskgroup");
3763 dump_omp_clauses (pp
, OMP_TASKGROUP_CLAUSES (node
), spc
, flags
);
3767 pp_string (pp
, "#pragma omp ordered");
3768 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3772 pp_string (pp
, "#pragma omp critical");
3773 if (OMP_CRITICAL_NAME (node
))
3777 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3779 pp_right_paren (pp
);
3781 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3785 pp_string (pp
, "#pragma omp atomic");
3786 if (OMP_ATOMIC_WEAK (node
))
3787 pp_string (pp
, " weak");
3788 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3789 newline_and_indent (pp
, spc
+ 2);
3790 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3794 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3797 case OMP_ATOMIC_READ
:
3798 pp_string (pp
, "#pragma omp atomic read");
3799 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3800 newline_and_indent (pp
, spc
+ 2);
3801 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3805 case OMP_ATOMIC_CAPTURE_OLD
:
3806 case OMP_ATOMIC_CAPTURE_NEW
:
3807 pp_string (pp
, "#pragma omp atomic capture");
3808 if (OMP_ATOMIC_WEAK (node
))
3809 pp_string (pp
, " weak");
3810 dump_omp_atomic_memory_order (pp
, OMP_ATOMIC_MEMORY_ORDER (node
));
3811 newline_and_indent (pp
, spc
+ 2);
3812 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3816 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3820 pp_string (pp
, "#pragma omp single");
3821 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3825 pp_string (pp
, "#pragma omp scope");
3826 dump_omp_clauses (pp
, OMP_SCOPE_CLAUSES (node
), spc
, flags
);
3830 /* If we come here, we're dumping something that's not an OMP construct,
3831 for example, OMP clauses attached to a function's '__attribute__'.
3832 Dump the whole OMP clause chain. */
3833 dump_omp_clauses (pp
, node
, spc
, flags
, false);
3837 case TRANSACTION_EXPR
:
3838 if (TRANSACTION_EXPR_OUTER (node
))
3839 pp_string (pp
, "__transaction_atomic [[outer]]");
3840 else if (TRANSACTION_EXPR_RELAXED (node
))
3841 pp_string (pp
, "__transaction_relaxed");
3843 pp_string (pp
, "__transaction_atomic");
3844 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3846 newline_and_indent (pp
, spc
);
3848 newline_and_indent (pp
, spc
+ 2);
3849 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3850 spc
+ 2, flags
, false);
3851 newline_and_indent (pp
, spc
);
3852 pp_right_brace (pp
);
3857 case VEC_SERIES_EXPR
:
3858 case VEC_WIDEN_MULT_HI_EXPR
:
3859 case VEC_WIDEN_MULT_LO_EXPR
:
3860 case VEC_WIDEN_MULT_EVEN_EXPR
:
3861 case VEC_WIDEN_MULT_ODD_EXPR
:
3862 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3863 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3865 for (str
= get_tree_code_name (code
); *str
; str
++)
3866 pp_character (pp
, TOUPPER (*str
));
3867 pp_string (pp
, " < ");
3868 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3869 pp_string (pp
, ", ");
3870 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3871 pp_string (pp
, " > ");
3874 case VEC_DUPLICATE_EXPR
:
3876 for (str
= get_tree_code_name (code
); *str
; str
++)
3877 pp_character (pp
, TOUPPER (*str
));
3878 pp_string (pp
, " < ");
3879 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3880 pp_string (pp
, " > ");
3883 case VEC_UNPACK_HI_EXPR
:
3884 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3885 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3886 pp_string (pp
, " > ");
3889 case VEC_UNPACK_LO_EXPR
:
3890 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3891 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3892 pp_string (pp
, " > ");
3895 case VEC_UNPACK_FLOAT_HI_EXPR
:
3896 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3897 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3898 pp_string (pp
, " > ");
3901 case VEC_UNPACK_FLOAT_LO_EXPR
:
3902 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3903 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3904 pp_string (pp
, " > ");
3907 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3908 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
3909 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3910 pp_string (pp
, " > ");
3913 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3914 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
3915 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3916 pp_string (pp
, " > ");
3919 case VEC_PACK_TRUNC_EXPR
:
3920 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3921 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3922 pp_string (pp
, ", ");
3923 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3924 pp_string (pp
, " > ");
3927 case VEC_PACK_SAT_EXPR
:
3928 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3929 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3930 pp_string (pp
, ", ");
3931 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3932 pp_string (pp
, " > ");
3935 case VEC_PACK_FIX_TRUNC_EXPR
:
3936 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3937 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3938 pp_string (pp
, ", ");
3939 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3940 pp_string (pp
, " > ");
3943 case VEC_PACK_FLOAT_EXPR
:
3944 pp_string (pp
, " VEC_PACK_FLOAT_EXPR < ");
3945 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3946 pp_string (pp
, ", ");
3947 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3948 pp_string (pp
, " > ");
3952 dump_block_node (pp
, node
, spc
, flags
);
3955 case DEBUG_BEGIN_STMT
:
3956 pp_string (pp
, "# DEBUG BEGIN STMT");
3963 if (is_stmt
&& is_expr
)
3969 /* Print the declaration of a variable. */
3972 print_declaration (pretty_printer
*pp
, tree t
, int spc
, dump_flags_t flags
)
3976 if (TREE_CODE(t
) == NAMELIST_DECL
)
3978 pp_string(pp
, "namelist ");
3979 dump_decl_name (pp
, t
, flags
);
3984 if (TREE_CODE (t
) == TYPE_DECL
)
3985 pp_string (pp
, "typedef ");
3987 if (HAS_RTL_P (t
) && DECL_REGISTER (t
))
3988 pp_string (pp
, "register ");
3990 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3991 pp_string (pp
, "extern ");
3992 else if (TREE_STATIC (t
))
3993 pp_string (pp
, "static ");
3995 /* Print the type and name. */
3996 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
4000 /* Print array's type. */
4001 tmp
= TREE_TYPE (t
);
4002 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
4003 tmp
= TREE_TYPE (tmp
);
4004 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
4006 /* Print variable's name. */
4008 dump_generic_node (pp
, t
, spc
, flags
, false);
4010 /* Print the dimensions. */
4011 tmp
= TREE_TYPE (t
);
4012 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
4014 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
4015 tmp
= TREE_TYPE (tmp
);
4018 else if (TREE_CODE (t
) == FUNCTION_DECL
)
4020 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
4022 dump_decl_name (pp
, t
, flags
);
4023 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
4027 /* Print type declaration. */
4028 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
4030 /* Print variable's name. */
4032 dump_generic_node (pp
, t
, spc
, flags
, false);
4035 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
4037 pp_string (pp
, " __asm__ ");
4039 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
4040 pp_right_paren (pp
);
4043 /* The initial value of a function serves to determine whether the function
4044 is declared or defined. So the following does not apply to function
4046 if (TREE_CODE (t
) != FUNCTION_DECL
)
4048 /* Print the initial value. */
4049 if (DECL_INITIAL (t
))
4054 if (!(flags
& TDF_SLIM
))
4055 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
4057 pp_string (pp
, "<<< omitted >>>");
4061 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
4063 pp_string (pp
, " [value-expr: ");
4064 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
4065 pp_right_bracket (pp
);
4072 /* Prints a structure: name, fields, and methods.
4073 FIXME: Still incomplete. */
4076 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
4079 /* Print the name of the structure. */
4080 if (TYPE_NAME (node
))
4083 if (TREE_CODE (node
) == RECORD_TYPE
)
4084 pp_string (pp
, "struct ");
4085 else if ((TREE_CODE (node
) == UNION_TYPE
4086 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
4087 pp_string (pp
, "union ");
4089 dump_generic_node (pp
, TYPE_NAME (node
), spc
, TDF_NONE
, false);
4092 /* Print the contents of the structure. */
4098 /* Print the fields of the structure. */
4101 tmp
= TYPE_FIELDS (node
);
4104 /* Avoid to print recursively the structure. */
4105 /* FIXME : Not implemented correctly...,
4106 what about the case when we have a cycle in the contain graph? ...
4107 Maybe this could be solved by looking at the scope in which the
4108 structure was declared. */
4109 if (TREE_TYPE (tmp
) != node
4110 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
4111 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
4113 print_declaration (pp
, tmp
, spc
+2, flags
);
4116 tmp
= DECL_CHAIN (tmp
);
4120 pp_right_brace (pp
);
4123 /* Return the priority of the operator CODE.
4125 From lowest to highest precedence with either left-to-right (L-R)
4126 or right-to-left (R-L) associativity]:
4129 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
4141 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
4142 15 [L-R] fn() [] -> .
4144 unary +, - and * have higher precedence than the corresponding binary
4148 op_code_prio (enum tree_code code
)
4165 case TRUTH_ORIF_EXPR
:
4168 case TRUTH_AND_EXPR
:
4169 case TRUTH_ANDIF_EXPR
:
4176 case TRUTH_XOR_EXPR
:
4193 case UNORDERED_EXPR
:
4204 case VEC_WIDEN_LSHIFT_HI_EXPR
:
4205 case VEC_WIDEN_LSHIFT_LO_EXPR
:
4206 case WIDEN_LSHIFT_EXPR
:
4209 case WIDEN_SUM_EXPR
:
4211 case POINTER_PLUS_EXPR
:
4212 case POINTER_DIFF_EXPR
:
4216 case VEC_WIDEN_MULT_HI_EXPR
:
4217 case VEC_WIDEN_MULT_LO_EXPR
:
4218 case WIDEN_MULT_EXPR
:
4220 case WIDEN_MULT_PLUS_EXPR
:
4221 case WIDEN_MULT_MINUS_EXPR
:
4223 case MULT_HIGHPART_EXPR
:
4224 case TRUNC_DIV_EXPR
:
4226 case FLOOR_DIV_EXPR
:
4227 case ROUND_DIV_EXPR
:
4229 case EXACT_DIV_EXPR
:
4230 case TRUNC_MOD_EXPR
:
4232 case FLOOR_MOD_EXPR
:
4233 case ROUND_MOD_EXPR
:
4236 case TRUTH_NOT_EXPR
:
4238 case POSTINCREMENT_EXPR
:
4239 case POSTDECREMENT_EXPR
:
4240 case PREINCREMENT_EXPR
:
4241 case PREDECREMENT_EXPR
:
4247 case FIX_TRUNC_EXPR
:
4253 case ARRAY_RANGE_REF
:
4257 /* Special expressions. */
4263 case VEC_UNPACK_HI_EXPR
:
4264 case VEC_UNPACK_LO_EXPR
:
4265 case VEC_UNPACK_FLOAT_HI_EXPR
:
4266 case VEC_UNPACK_FLOAT_LO_EXPR
:
4267 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
4268 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
4269 case VEC_PACK_TRUNC_EXPR
:
4270 case VEC_PACK_SAT_EXPR
:
4274 /* Return an arbitrarily high precedence to avoid surrounding single
4275 VAR_DECLs in ()s. */
4280 /* Return the priority of the operator OP. */
4283 op_prio (const_tree op
)
4285 enum tree_code code
;
4290 code
= TREE_CODE (op
);
4291 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
4292 return op_prio (TREE_OPERAND (op
, 0));
4294 return op_code_prio (code
);
4297 /* Return the symbol associated with operator CODE. */
4300 op_symbol_code (enum tree_code code
)
4308 case TRUTH_ORIF_EXPR
:
4311 case TRUTH_AND_EXPR
:
4312 case TRUTH_ANDIF_EXPR
:
4318 case TRUTH_XOR_EXPR
:
4328 case UNORDERED_EXPR
:
4374 case WIDEN_LSHIFT_EXPR
:
4377 case POINTER_PLUS_EXPR
:
4383 case WIDEN_SUM_EXPR
:
4386 case WIDEN_MULT_EXPR
:
4389 case MULT_HIGHPART_EXPR
:
4394 case POINTER_DIFF_EXPR
:
4400 case TRUTH_NOT_EXPR
:
4407 case TRUNC_DIV_EXPR
:
4414 case FLOOR_DIV_EXPR
:
4417 case ROUND_DIV_EXPR
:
4420 case EXACT_DIV_EXPR
:
4423 case TRUNC_MOD_EXPR
:
4429 case FLOOR_MOD_EXPR
:
4432 case ROUND_MOD_EXPR
:
4435 case PREDECREMENT_EXPR
:
4438 case PREINCREMENT_EXPR
:
4441 case POSTDECREMENT_EXPR
:
4444 case POSTINCREMENT_EXPR
:
4454 return "<<< ??? >>>";
4458 /* Return the symbol associated with operator OP. */
4461 op_symbol (const_tree op
)
4463 return op_symbol_code (TREE_CODE (op
));
4466 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
4467 the gimple_call_fn of a GIMPLE_CALL. */
4470 print_call_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
4475 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
4476 op0
= TREE_OPERAND (op0
, 0);
4479 switch (TREE_CODE (op0
))
4484 dump_function_name (pp
, op0
, flags
);
4490 op0
= TREE_OPERAND (op0
, 0);
4495 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
4496 pp_string (pp
, ") ? ");
4497 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
4498 pp_string (pp
, " : ");
4499 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
4503 if (VAR_P (TREE_OPERAND (op0
, 0)))
4504 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
4506 dump_generic_node (pp
, op0
, 0, flags
, false);
4510 if (integer_zerop (TREE_OPERAND (op0
, 1)))
4512 op0
= TREE_OPERAND (op0
, 0);
4519 dump_generic_node (pp
, op0
, 0, flags
, false);
4527 /* Print the first N characters in the array STR, replacing non-printable
4528 characters (including embedded nuls) with unambiguous escape sequences. */
4531 pretty_print_string (pretty_printer
*pp
, const char *str
, size_t n
)
4536 for ( ; n
; --n
, ++str
)
4541 pp_string (pp
, "\\b");
4545 pp_string (pp
, "\\f");
4549 pp_string (pp
, "\\n");
4553 pp_string (pp
, "\\r");
4557 pp_string (pp
, "\\t");
4561 pp_string (pp
, "\\v");
4565 pp_string (pp
, "\\\\");
4569 pp_string (pp
, "\\\"");
4573 pp_string (pp
, "\\'");
4577 if (str
[0] || n
> 1)
4579 if (!ISPRINT (str
[0]))
4582 sprintf (buf
, "\\x%02x", (unsigned char)str
[0]);
4583 pp_string (pp
, buf
);
4586 pp_character (pp
, str
[0]);
4594 maybe_init_pretty_print (FILE *file
)
4598 tree_pp
= new pretty_printer ();
4599 pp_needs_newline (tree_pp
) = true;
4600 pp_translate_identifiers (tree_pp
) = false;
4603 tree_pp
->buffer
->stream
= file
;
4607 newline_and_indent (pretty_printer
*pp
, int spc
)
4613 /* Print the identifier ID to PRETTY-PRINTER. */
4616 pp_tree_identifier (pretty_printer
*pp
, tree id
)
4618 if (pp_translate_identifiers (pp
))
4620 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
4621 pp_append_text (pp
, text
, text
+ strlen (text
));
4624 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
4625 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
4628 /* A helper function that is used to dump function information before the
4632 dump_function_header (FILE *dump_file
, tree fdecl
, dump_flags_t flags
)
4634 const char *dname
, *aname
;
4635 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
4636 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
4638 dname
= lang_hooks
.decl_printable_name (fdecl
, 1);
4640 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
4641 aname
= (IDENTIFIER_POINTER
4642 (DECL_ASSEMBLER_NAME (fdecl
)));
4644 aname
= "<unset-asm-name>";
4646 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
4647 dname
, aname
, fun
->funcdef_no
);
4648 if (!(flags
& TDF_NOUID
))
4649 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
4652 fprintf (dump_file
, ", cgraph_uid=%d", node
->get_uid ());
4653 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
4654 node
->frequency
== NODE_FREQUENCY_HOT
4656 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
4657 ? " (unlikely executed)"
4658 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
4659 ? " (executed once)"
4663 fprintf (dump_file
, ")\n\n");
4666 /* Dump double_int D to pretty_printer PP. UNS is true
4667 if D is unsigned and false otherwise. */
4669 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4672 pp_wide_integer (pp
, d
.low
);
4673 else if (d
.fits_uhwi ())
4674 pp_unsigned_wide_integer (pp
, d
.low
);
4677 unsigned HOST_WIDE_INT low
= d
.low
;
4678 HOST_WIDE_INT high
= d
.high
;
4679 if (!uns
&& d
.is_negative ())
4682 high
= ~high
+ !low
;
4685 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4687 sprintf (pp_buffer (pp
)->digit_buffer
,
4688 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4689 (unsigned HOST_WIDE_INT
) high
, low
);
4690 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
4695 # pragma GCC diagnostic pop