1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2017 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
29 #include "tree-pretty-print.h"
30 #include "stor-layout.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
34 #include "internal-fn.h"
35 #include "gomp-constants.h"
38 /* Local functions, macros and variables. */
39 static const char *op_symbol (const_tree
);
40 static void pretty_print_string (pretty_printer
*, const char*);
41 static void newline_and_indent (pretty_printer
*, int);
42 static void maybe_init_pretty_print (FILE *);
43 static void print_struct_decl (pretty_printer
*, const_tree
, int, dump_flags_t
);
44 static void do_niy (pretty_printer
*, const_tree
, dump_flags_t
);
46 #define INDENT(SPACE) do { \
47 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
49 #define NIY do_niy (pp, node, flags)
51 static pretty_printer
*tree_pp
;
53 /* Try to print something for an unknown tree code. */
56 do_niy (pretty_printer
*pp
, const_tree node
, dump_flags_t flags
)
60 pp_string (pp
, "<<< Unknown tree: ");
61 pp_string (pp
, get_tree_code_name (TREE_CODE (node
)));
65 len
= TREE_OPERAND_LENGTH (node
);
66 for (i
= 0; i
< len
; ++i
)
68 newline_and_indent (pp
, 2);
69 dump_generic_node (pp
, TREE_OPERAND (node
, i
), 2, flags
, false);
73 pp_string (pp
, " >>>");
76 /* Debugging function to print out a generic expression. */
79 debug_generic_expr (tree t
)
81 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
82 fprintf (stderr
, "\n");
85 /* Debugging function to print out a generic statement. */
88 debug_generic_stmt (tree t
)
90 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
91 fprintf (stderr
, "\n");
94 /* Debugging function to print out a chain of trees . */
97 debug_tree_chain (tree t
)
103 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
104 fprintf (stderr
, " ");
108 fprintf (stderr
, "... [cycled back to ");
109 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
110 fprintf (stderr
, "]");
114 fprintf (stderr
, "\n");
117 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
119 print_generic_decl (FILE *file
, tree decl
, dump_flags_t flags
)
121 maybe_init_pretty_print (file
);
122 print_declaration (tree_pp
, decl
, 2, flags
);
123 pp_write_text_to_stream (tree_pp
);
126 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
127 to show in the dump. See TDF_* in dumpfile.h. */
130 print_generic_stmt (FILE *file
, tree t
, dump_flags_t flags
)
132 maybe_init_pretty_print (file
);
133 dump_generic_node (tree_pp
, t
, 0, flags
, true);
134 pp_newline_and_flush (tree_pp
);
137 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
138 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
142 print_generic_stmt_indented (FILE *file
, tree t
, dump_flags_t flags
, int indent
)
146 maybe_init_pretty_print (file
);
148 for (i
= 0; i
< indent
; i
++)
150 dump_generic_node (tree_pp
, t
, indent
, flags
, true);
151 pp_newline_and_flush (tree_pp
);
154 /* Print a single expression T on file FILE. FLAGS specifies details to show
155 in the dump. See TDF_* in dumpfile.h. */
158 print_generic_expr (FILE *file
, tree t
, dump_flags_t flags
)
160 maybe_init_pretty_print (file
);
161 dump_generic_node (tree_pp
, t
, 0, flags
, false);
165 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
166 in it are replaced with Dxxxx, as long as they are at the start or
167 preceded by $ and at the end or followed by $. See make_fancy_name
171 dump_fancy_name (pretty_printer
*pp
, tree name
)
174 int length
= IDENTIFIER_LENGTH (name
);
175 const char *n
= IDENTIFIER_POINTER (name
);
182 && (n
== IDENTIFIER_POINTER (name
) || n
[-1] == '$'))
185 while (ISDIGIT (n
[l
]))
187 if (n
[l
] == '\0' || n
[l
] == '$')
200 pp_tree_identifier (pp
, name
);
204 char *str
= XNEWVEC (char, length
+ 1);
207 q
= n
= IDENTIFIER_POINTER (name
);
214 && (q
== IDENTIFIER_POINTER (name
) || q
[-1] == '$'))
217 while (ISDIGIT (q
[l
]))
219 if (q
[l
] == '\0' || q
[l
] == '$')
221 memcpy (p
, n
, q
- n
);
222 memcpy (p
+ (q
- n
), "Dxxxx", 5);
232 memcpy (p
, n
, IDENTIFIER_LENGTH (name
) - (n
- IDENTIFIER_POINTER (name
)));
234 if (pp_translate_identifiers (pp
))
236 const char *text
= identifier_to_locale (str
);
237 pp_append_text (pp
, text
, text
+ strlen (text
));
240 pp_append_text (pp
, str
, str
+ length
);
244 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
248 dump_decl_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
250 if (DECL_NAME (node
))
252 if ((flags
& TDF_ASMNAME
)
253 && HAS_DECL_ASSEMBLER_NAME_P (node
)
254 && DECL_ASSEMBLER_NAME_SET_P (node
))
255 pp_tree_identifier (pp
, DECL_ASSEMBLER_NAME_RAW (node
));
256 /* For DECL_NAMELESS names look for embedded uids in the
257 names and sanitize them for TDF_NOUID. */
258 else if ((flags
& TDF_NOUID
) && DECL_NAMELESS (node
))
259 dump_fancy_name (pp
, DECL_NAME (node
));
261 pp_tree_identifier (pp
, DECL_NAME (node
));
263 char uid_sep
= (flags
& TDF_GIMPLE
) ? '_' : '.';
264 if ((flags
& TDF_UID
) || DECL_NAME (node
) == NULL_TREE
)
266 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
267 pp_printf (pp
, "L%c%d", uid_sep
, (int) LABEL_DECL_UID (node
));
268 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
270 if (flags
& TDF_NOUID
)
271 pp_string (pp
, "D#xxxx");
273 pp_printf (pp
, "D#%i", DEBUG_TEMP_UID (node
));
277 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
278 if (flags
& TDF_NOUID
)
279 pp_printf (pp
, "%c.xxxx", c
);
281 pp_printf (pp
, "%c%c%u", c
, uid_sep
, DECL_UID (node
));
284 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
286 if (flags
& TDF_NOUID
)
287 pp_printf (pp
, "ptD.xxxx");
289 pp_printf (pp
, "ptD.%u", DECL_PT_UID (node
));
293 /* Like the above, but used for pretty printing function calls. */
296 dump_function_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
298 if (CONVERT_EXPR_P (node
))
299 node
= TREE_OPERAND (node
, 0);
300 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
301 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
303 dump_decl_name (pp
, node
, flags
);
306 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
307 FLAGS are as in dump_generic_node. */
310 dump_function_declaration (pretty_printer
*pp
, tree node
,
311 int spc
, dump_flags_t flags
)
313 bool wrote_arg
= false;
319 /* Print the argument types. */
320 arg
= TYPE_ARG_TYPES (node
);
321 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
329 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
330 arg
= TREE_CHAIN (arg
);
333 /* Drop the trailing void_type_node if we had any previous argument. */
334 if (arg
== void_list_node
&& !wrote_arg
)
335 pp_string (pp
, "void");
336 /* Properly dump vararg function types. */
337 else if (!arg
&& wrote_arg
)
338 pp_string (pp
, ", ...");
339 /* Avoid printing any arg for unprototyped functions. */
344 /* Dump the domain associated with an array. */
347 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, dump_flags_t flags
)
349 pp_left_bracket (pp
);
352 tree min
= TYPE_MIN_VALUE (domain
);
353 tree max
= TYPE_MAX_VALUE (domain
);
356 && integer_zerop (min
)
357 && tree_fits_shwi_p (max
))
358 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
362 dump_generic_node (pp
, min
, spc
, flags
, false);
365 dump_generic_node (pp
, max
, spc
, flags
, false);
369 pp_string (pp
, "<unknown>");
370 pp_right_bracket (pp
);
374 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
375 dump_generic_node. */
378 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
382 switch (OMP_CLAUSE_CODE (clause
))
384 case OMP_CLAUSE_PRIVATE
:
387 case OMP_CLAUSE_SHARED
:
390 case OMP_CLAUSE_FIRSTPRIVATE
:
391 name
= "firstprivate";
393 case OMP_CLAUSE_LASTPRIVATE
:
394 name
= "lastprivate";
396 case OMP_CLAUSE_COPYIN
:
399 case OMP_CLAUSE_COPYPRIVATE
:
400 name
= "copyprivate";
402 case OMP_CLAUSE_UNIFORM
:
405 case OMP_CLAUSE_USE_DEVICE_PTR
:
406 name
= "use_device_ptr";
408 case OMP_CLAUSE_IS_DEVICE_PTR
:
409 name
= "is_device_ptr";
411 case OMP_CLAUSE__LOOPTEMP_
:
414 case OMP_CLAUSE_TO_DECLARE
:
417 case OMP_CLAUSE_LINK
:
421 pp_string (pp
, name
);
423 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
428 case OMP_CLAUSE_REDUCTION
:
429 pp_string (pp
, "reduction(");
430 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
433 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
436 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
442 pp_string (pp
, "if(");
443 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
445 case ERROR_MARK
: break;
446 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
447 case OMP_TASK
: pp_string (pp
, "task:"); break;
448 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
449 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
450 case OMP_TARGET
: pp_string (pp
, "target:"); break;
451 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
452 case OMP_TARGET_ENTER_DATA
:
453 pp_string (pp
, "target enter data:"); break;
454 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
455 default: gcc_unreachable ();
457 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
462 case OMP_CLAUSE_NUM_THREADS
:
463 pp_string (pp
, "num_threads(");
464 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
469 case OMP_CLAUSE__CILK_FOR_COUNT_
:
470 pp_string (pp
, "_Cilk_for_count_(");
471 dump_generic_node (pp
, OMP_CLAUSE_OPERAND (clause
, 0),
476 case OMP_CLAUSE_NOWAIT
:
477 pp_string (pp
, "nowait");
479 case OMP_CLAUSE_ORDERED
:
480 pp_string (pp
, "ordered");
481 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
484 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
490 case OMP_CLAUSE_DEFAULT
:
491 pp_string (pp
, "default(");
492 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
494 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
496 case OMP_CLAUSE_DEFAULT_SHARED
:
497 pp_string (pp
, "shared");
499 case OMP_CLAUSE_DEFAULT_NONE
:
500 pp_string (pp
, "none");
502 case OMP_CLAUSE_DEFAULT_PRIVATE
:
503 pp_string (pp
, "private");
505 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
506 pp_string (pp
, "firstprivate");
508 case OMP_CLAUSE_DEFAULT_PRESENT
:
509 pp_string (pp
, "present");
517 case OMP_CLAUSE_SCHEDULE
:
518 pp_string (pp
, "schedule(");
519 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
520 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
521 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
523 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
524 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
525 pp_string (pp
, "monotonic");
527 pp_string (pp
, "nonmonotonic");
528 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
533 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
534 pp_string (pp
, "simd:");
536 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
538 case OMP_CLAUSE_SCHEDULE_STATIC
:
539 pp_string (pp
, "static");
541 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
542 pp_string (pp
, "dynamic");
544 case OMP_CLAUSE_SCHEDULE_GUIDED
:
545 pp_string (pp
, "guided");
547 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
548 pp_string (pp
, "runtime");
550 case OMP_CLAUSE_SCHEDULE_AUTO
:
551 pp_string (pp
, "auto");
553 case OMP_CLAUSE_SCHEDULE_CILKFOR
:
554 pp_string (pp
, "cilk-for grain");
559 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
562 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
568 case OMP_CLAUSE_UNTIED
:
569 pp_string (pp
, "untied");
572 case OMP_CLAUSE_COLLAPSE
:
573 pp_string (pp
, "collapse(");
574 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
579 case OMP_CLAUSE_FINAL
:
580 pp_string (pp
, "final(");
581 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
586 case OMP_CLAUSE_MERGEABLE
:
587 pp_string (pp
, "mergeable");
590 case OMP_CLAUSE_LINEAR
:
591 pp_string (pp
, "linear(");
592 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
594 case OMP_CLAUSE_LINEAR_DEFAULT
:
596 case OMP_CLAUSE_LINEAR_REF
:
597 pp_string (pp
, "ref(");
599 case OMP_CLAUSE_LINEAR_VAL
:
600 pp_string (pp
, "val(");
602 case OMP_CLAUSE_LINEAR_UVAL
:
603 pp_string (pp
, "uval(");
608 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
610 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
613 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
618 case OMP_CLAUSE_ALIGNED
:
619 pp_string (pp
, "aligned(");
620 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
622 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
625 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
631 case OMP_CLAUSE_DEPEND
:
632 pp_string (pp
, "depend(");
633 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
635 case OMP_CLAUSE_DEPEND_IN
:
636 pp_string (pp
, "in");
638 case OMP_CLAUSE_DEPEND_OUT
:
639 pp_string (pp
, "out");
641 case OMP_CLAUSE_DEPEND_INOUT
:
642 pp_string (pp
, "inout");
644 case OMP_CLAUSE_DEPEND_SOURCE
:
645 pp_string (pp
, "source)");
647 case OMP_CLAUSE_DEPEND_SINK
:
648 pp_string (pp
, "sink:");
649 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
650 if (TREE_CODE (t
) == TREE_LIST
)
652 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
653 if (TREE_PURPOSE (t
) != integer_zero_node
)
655 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
659 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
673 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
679 pp_string (pp
, "map(");
680 switch (OMP_CLAUSE_MAP_KIND (clause
))
683 case GOMP_MAP_POINTER
:
684 pp_string (pp
, "alloc");
687 case GOMP_MAP_TO_PSET
:
688 pp_string (pp
, "to");
691 pp_string (pp
, "from");
693 case GOMP_MAP_TOFROM
:
694 pp_string (pp
, "tofrom");
696 case GOMP_MAP_FORCE_ALLOC
:
697 pp_string (pp
, "force_alloc");
699 case GOMP_MAP_FORCE_TO
:
700 pp_string (pp
, "force_to");
702 case GOMP_MAP_FORCE_FROM
:
703 pp_string (pp
, "force_from");
705 case GOMP_MAP_FORCE_TOFROM
:
706 pp_string (pp
, "force_tofrom");
708 case GOMP_MAP_FORCE_PRESENT
:
709 pp_string (pp
, "force_present");
711 case GOMP_MAP_DELETE
:
712 pp_string (pp
, "delete");
714 case GOMP_MAP_FORCE_DEVICEPTR
:
715 pp_string (pp
, "force_deviceptr");
717 case GOMP_MAP_ALWAYS_TO
:
718 pp_string (pp
, "always,to");
720 case GOMP_MAP_ALWAYS_FROM
:
721 pp_string (pp
, "always,from");
723 case GOMP_MAP_ALWAYS_TOFROM
:
724 pp_string (pp
, "always,tofrom");
726 case GOMP_MAP_RELEASE
:
727 pp_string (pp
, "release");
729 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
730 pp_string (pp
, "firstprivate");
732 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
733 pp_string (pp
, "firstprivate ref");
735 case GOMP_MAP_STRUCT
:
736 pp_string (pp
, "struct");
738 case GOMP_MAP_ALWAYS_POINTER
:
739 pp_string (pp
, "always_pointer");
741 case GOMP_MAP_DEVICE_RESIDENT
:
742 pp_string (pp
, "device_resident");
745 pp_string (pp
, "link");
751 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
754 if (OMP_CLAUSE_SIZE (clause
))
756 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
757 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
759 case GOMP_MAP_POINTER
:
760 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
761 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
762 case GOMP_MAP_ALWAYS_POINTER
:
763 pp_string (pp
, " [pointer assign, bias: ");
765 case GOMP_MAP_TO_PSET
:
766 pp_string (pp
, " [pointer set, len: ");
769 pp_string (pp
, " [len: ");
772 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
774 pp_right_bracket (pp
);
779 case OMP_CLAUSE_FROM
:
780 pp_string (pp
, "from(");
781 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
783 goto print_clause_size
;
786 pp_string (pp
, "to(");
787 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
789 goto print_clause_size
;
791 case OMP_CLAUSE__CACHE_
:
793 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
795 goto print_clause_size
;
797 case OMP_CLAUSE_NUM_TEAMS
:
798 pp_string (pp
, "num_teams(");
799 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
804 case OMP_CLAUSE_THREAD_LIMIT
:
805 pp_string (pp
, "thread_limit(");
806 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
811 case OMP_CLAUSE_DEVICE
:
812 pp_string (pp
, "device(");
813 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
818 case OMP_CLAUSE_DIST_SCHEDULE
:
819 pp_string (pp
, "dist_schedule(static");
820 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
823 dump_generic_node (pp
,
824 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
830 case OMP_CLAUSE_PROC_BIND
:
831 pp_string (pp
, "proc_bind(");
832 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
834 case OMP_CLAUSE_PROC_BIND_MASTER
:
835 pp_string (pp
, "master");
837 case OMP_CLAUSE_PROC_BIND_CLOSE
:
838 pp_string (pp
, "close");
840 case OMP_CLAUSE_PROC_BIND_SPREAD
:
841 pp_string (pp
, "spread");
849 case OMP_CLAUSE_SAFELEN
:
850 pp_string (pp
, "safelen(");
851 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
856 case OMP_CLAUSE_SIMDLEN
:
857 pp_string (pp
, "simdlen(");
858 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
863 case OMP_CLAUSE_PRIORITY
:
864 pp_string (pp
, "priority(");
865 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
870 case OMP_CLAUSE_GRAINSIZE
:
871 pp_string (pp
, "grainsize(");
872 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
877 case OMP_CLAUSE_NUM_TASKS
:
878 pp_string (pp
, "num_tasks(");
879 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
884 case OMP_CLAUSE_HINT
:
885 pp_string (pp
, "hint(");
886 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
891 case OMP_CLAUSE_DEFAULTMAP
:
892 pp_string (pp
, "defaultmap(tofrom:scalar)");
895 case OMP_CLAUSE__SIMDUID_
:
896 pp_string (pp
, "_simduid_(");
897 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
902 case OMP_CLAUSE__SIMT_
:
903 pp_string (pp
, "_simt_");
906 case OMP_CLAUSE_GANG
:
907 pp_string (pp
, "gang");
908 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
910 pp_string (pp
, "(num: ");
911 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
914 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
916 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
920 pp_string (pp
, "static:");
921 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
922 == integer_minus_one_node
)
923 pp_character (pp
, '*');
925 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
928 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
929 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
933 case OMP_CLAUSE_ASYNC
:
934 pp_string (pp
, "async");
935 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
937 pp_character(pp
, '(');
938 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
940 pp_character(pp
, ')');
944 case OMP_CLAUSE_AUTO
:
946 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
949 case OMP_CLAUSE_WAIT
:
950 pp_string (pp
, "wait(");
951 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
953 pp_character(pp
, ')');
956 case OMP_CLAUSE_WORKER
:
957 pp_string (pp
, "worker");
958 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
961 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
967 case OMP_CLAUSE_VECTOR
:
968 pp_string (pp
, "vector");
969 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
972 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
978 case OMP_CLAUSE_NUM_GANGS
:
979 pp_string (pp
, "num_gangs(");
980 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
982 pp_character (pp
, ')');
985 case OMP_CLAUSE_NUM_WORKERS
:
986 pp_string (pp
, "num_workers(");
987 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
989 pp_character (pp
, ')');
992 case OMP_CLAUSE_VECTOR_LENGTH
:
993 pp_string (pp
, "vector_length(");
994 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
996 pp_character (pp
, ')');
999 case OMP_CLAUSE_INBRANCH
:
1000 pp_string (pp
, "inbranch");
1002 case OMP_CLAUSE_NOTINBRANCH
:
1003 pp_string (pp
, "notinbranch");
1005 case OMP_CLAUSE_FOR
:
1006 pp_string (pp
, "for");
1008 case OMP_CLAUSE_PARALLEL
:
1009 pp_string (pp
, "parallel");
1011 case OMP_CLAUSE_SECTIONS
:
1012 pp_string (pp
, "sections");
1014 case OMP_CLAUSE_TASKGROUP
:
1015 pp_string (pp
, "taskgroup");
1017 case OMP_CLAUSE_NOGROUP
:
1018 pp_string (pp
, "nogroup");
1020 case OMP_CLAUSE_THREADS
:
1021 pp_string (pp
, "threads");
1023 case OMP_CLAUSE_SIMD
:
1024 pp_string (pp
, "simd");
1026 case OMP_CLAUSE_INDEPENDENT
:
1027 pp_string (pp
, "independent");
1029 case OMP_CLAUSE_TILE
:
1030 pp_string (pp
, "tile(");
1031 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1033 pp_right_paren (pp
);
1036 case OMP_CLAUSE__GRIDDIM_
:
1037 pp_string (pp
, "_griddim_(");
1038 pp_unsigned_wide_integer (pp
, OMP_CLAUSE__GRIDDIM__DIMENSION (clause
));
1040 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__SIZE (clause
), spc
, flags
,
1043 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__GROUP (clause
), spc
, flags
,
1045 pp_right_paren (pp
);
1049 /* Should never happen. */
1050 dump_generic_node (pp
, clause
, spc
, flags
, false);
1056 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1057 dump_generic_node. */
1060 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
1068 dump_omp_clause (pp
, clause
, spc
, flags
);
1069 clause
= OMP_CLAUSE_CHAIN (clause
);
1077 /* Dump location LOC to PP. */
1080 dump_location (pretty_printer
*pp
, location_t loc
)
1082 expanded_location xloc
= expand_location (loc
);
1084 pp_left_bracket (pp
);
1087 pp_string (pp
, xloc
.file
);
1088 pp_string (pp
, ":");
1090 pp_decimal_int (pp
, xloc
.line
);
1092 pp_decimal_int (pp
, xloc
.column
);
1093 pp_string (pp
, "] ");
1097 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1098 dump_generic_node. */
1101 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, dump_flags_t flags
)
1105 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1107 if (flags
& TDF_ADDRESS
)
1108 pp_printf (pp
, "[%p] ", (void *) block
);
1110 if (BLOCK_ABSTRACT (block
))
1111 pp_string (pp
, "[abstract] ");
1113 if (TREE_ASM_WRITTEN (block
))
1114 pp_string (pp
, "[written] ");
1116 if (flags
& TDF_SLIM
)
1119 if (BLOCK_SOURCE_LOCATION (block
))
1120 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1122 newline_and_indent (pp
, spc
+ 2);
1124 if (BLOCK_SUPERCONTEXT (block
))
1126 pp_string (pp
, "SUPERCONTEXT: ");
1127 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1128 flags
| TDF_SLIM
, false);
1129 newline_and_indent (pp
, spc
+ 2);
1132 if (BLOCK_SUBBLOCKS (block
))
1134 pp_string (pp
, "SUBBLOCKS: ");
1135 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1137 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1140 newline_and_indent (pp
, spc
+ 2);
1143 if (BLOCK_CHAIN (block
))
1145 pp_string (pp
, "SIBLINGS: ");
1146 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1148 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1151 newline_and_indent (pp
, spc
+ 2);
1154 if (BLOCK_VARS (block
))
1156 pp_string (pp
, "VARS: ");
1157 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1159 dump_generic_node (pp
, t
, 0, flags
, false);
1162 newline_and_indent (pp
, spc
+ 2);
1165 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1168 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1170 pp_string (pp
, "NONLOCALIZED_VARS: ");
1171 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1173 dump_generic_node (pp
, t
, 0, flags
, false);
1176 newline_and_indent (pp
, spc
+ 2);
1179 if (BLOCK_ABSTRACT_ORIGIN (block
))
1181 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1182 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1183 flags
| TDF_SLIM
, false);
1184 newline_and_indent (pp
, spc
+ 2);
1187 if (BLOCK_FRAGMENT_ORIGIN (block
))
1189 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1190 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1191 flags
| TDF_SLIM
, false);
1192 newline_and_indent (pp
, spc
+ 2);
1195 if (BLOCK_FRAGMENT_CHAIN (block
))
1197 pp_string (pp
, "FRAGMENT_CHAIN: ");
1198 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1200 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1203 newline_and_indent (pp
, spc
+ 2);
1208 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1209 indent. FLAGS specifies details to show in the dump (see TDF_* in
1210 dumpfile.h). If IS_STMT is true, the object printed is considered
1211 to be a statement and it is terminated by ';' if appropriate. */
1214 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
,
1221 enum tree_code code
;
1223 if (node
== NULL_TREE
)
1226 is_expr
= EXPR_P (node
);
1228 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1229 pp_printf (pp
, "<&%p> ", (void *)node
);
1231 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1232 dump_location (pp
, EXPR_LOCATION (node
));
1234 code
= TREE_CODE (node
);
1238 pp_string (pp
, "<<< error >>>");
1241 case IDENTIFIER_NODE
:
1242 pp_tree_identifier (pp
, node
);
1246 while (node
&& node
!= error_mark_node
)
1248 if (TREE_PURPOSE (node
))
1250 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1253 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1254 node
= TREE_CHAIN (node
);
1255 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1264 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1270 if (TREE_VEC_LENGTH (node
) > 0)
1272 size_t len
= TREE_VEC_LENGTH (node
);
1273 for (i
= 0; i
< len
- 1; i
++)
1275 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1280 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1287 case POINTER_BOUNDS_TYPE
:
1290 case FIXED_POINT_TYPE
:
1296 unsigned int quals
= TYPE_QUALS (node
);
1297 enum tree_code_class tclass
;
1299 if (quals
& TYPE_QUAL_ATOMIC
)
1300 pp_string (pp
, "atomic ");
1301 if (quals
& TYPE_QUAL_CONST
)
1302 pp_string (pp
, "const ");
1303 else if (quals
& TYPE_QUAL_VOLATILE
)
1304 pp_string (pp
, "volatile ");
1305 else if (quals
& TYPE_QUAL_RESTRICT
)
1306 pp_string (pp
, "restrict ");
1308 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1310 pp_string (pp
, "<address-space-");
1311 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1312 pp_string (pp
, "> ");
1315 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1317 if (tclass
== tcc_declaration
)
1319 if (DECL_NAME (node
))
1320 dump_decl_name (pp
, node
, flags
);
1322 pp_string (pp
, "<unnamed type decl>");
1324 else if (tclass
== tcc_type
)
1326 if (TYPE_NAME (node
))
1328 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1329 pp_tree_identifier (pp
, TYPE_NAME (node
));
1330 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1331 && DECL_NAME (TYPE_NAME (node
)))
1332 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1334 pp_string (pp
, "<unnamed type>");
1336 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1338 pp_string (pp
, "vector");
1340 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1341 pp_string (pp
, ") ");
1342 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1344 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1346 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1347 pp_string (pp
, (TYPE_UNSIGNED (node
)
1350 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1351 pp_string (pp
, (TYPE_UNSIGNED (node
)
1354 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1355 pp_string (pp
, (TYPE_UNSIGNED (node
)
1358 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1359 pp_string (pp
, (TYPE_UNSIGNED (node
)
1362 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1363 pp_string (pp
, (TYPE_UNSIGNED (node
)
1364 ? "unsigned long long"
1365 : "signed long long"));
1366 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1367 && pow2p_hwi (TYPE_PRECISION (node
)))
1369 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1370 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1371 pp_string (pp
, "_t");
1375 pp_string (pp
, (TYPE_UNSIGNED (node
)
1376 ? "<unnamed-unsigned:"
1377 : "<unnamed-signed:"));
1378 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1382 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1384 pp_string (pp
, "__complex__ ");
1385 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1387 else if (TREE_CODE (node
) == REAL_TYPE
)
1389 pp_string (pp
, "<float:");
1390 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1393 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1395 pp_string (pp
, "<fixed-point-");
1396 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1397 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1400 else if (TREE_CODE (node
) == VOID_TYPE
)
1401 pp_string (pp
, "void");
1403 pp_string (pp
, "<unnamed type>");
1409 case REFERENCE_TYPE
:
1410 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1412 if (TREE_TYPE (node
) == NULL
)
1414 pp_string (pp
, str
);
1415 pp_string (pp
, "<null type>");
1417 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1419 tree fnode
= TREE_TYPE (node
);
1421 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1424 pp_string (pp
, str
);
1425 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1426 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1427 else if (flags
& TDF_NOUID
)
1428 pp_printf (pp
, "<Txxxx>");
1430 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1432 pp_right_paren (pp
);
1433 dump_function_declaration (pp
, fnode
, spc
, flags
);
1437 unsigned int quals
= TYPE_QUALS (node
);
1439 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1441 pp_string (pp
, str
);
1443 if (quals
& TYPE_QUAL_CONST
)
1444 pp_string (pp
, " const");
1445 if (quals
& TYPE_QUAL_VOLATILE
)
1446 pp_string (pp
, " volatile");
1447 if (quals
& TYPE_QUAL_RESTRICT
)
1448 pp_string (pp
, " restrict");
1450 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1452 pp_string (pp
, " <address-space-");
1453 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1457 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1458 pp_string (pp
, " {ref-all}");
1468 if (flags
& TDF_GIMPLE
)
1470 pp_string (pp
, "__MEM <");
1471 dump_generic_node (pp
, TREE_TYPE (node
),
1472 spc
, flags
| TDF_SLIM
, false);
1473 if (TYPE_ALIGN (TREE_TYPE (node
))
1474 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
1476 pp_string (pp
, ", ");
1477 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
1480 pp_string (pp
, " (");
1481 if (TREE_TYPE (TREE_OPERAND (node
, 0))
1482 != TREE_TYPE (TREE_OPERAND (node
, 1)))
1485 dump_generic_node (pp
, TREE_TYPE (TREE_OPERAND (node
, 1)),
1486 spc
, flags
| TDF_SLIM
, false);
1487 pp_right_paren (pp
);
1489 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1490 spc
, flags
| TDF_SLIM
, false);
1491 if (! integer_zerop (TREE_OPERAND (node
, 1)))
1493 pp_string (pp
, " + ");
1494 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1495 spc
, flags
| TDF_SLIM
, false);
1497 pp_right_paren (pp
);
1499 else if (integer_zerop (TREE_OPERAND (node
, 1))
1500 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1501 infer them and MEM_ATTR caching will share MEM_REFs
1502 with differently-typed op0s. */
1503 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1504 /* Released SSA_NAMES have no TREE_TYPE. */
1505 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1506 /* Same pointer types, but ignoring POINTER_TYPE vs.
1508 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1509 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1510 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1511 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1512 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1513 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1514 /* Same value types ignoring qualifiers. */
1515 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1516 == TYPE_MAIN_VARIANT
1517 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1518 && (!(flags
& TDF_ALIAS
)
1519 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1521 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1524 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1528 dump_generic_node (pp
,
1529 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1536 pp_string (pp
, "MEM[");
1538 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1539 dump_generic_node (pp
, ptype
,
1540 spc
, flags
| TDF_SLIM
, false);
1541 pp_right_paren (pp
);
1542 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1544 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1546 pp_string (pp
, " + ");
1547 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1550 if ((flags
& TDF_ALIAS
)
1551 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1553 pp_string (pp
, " clique ");
1554 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1555 pp_string (pp
, " base ");
1556 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1558 pp_right_bracket (pp
);
1563 case TARGET_MEM_REF
:
1565 const char *sep
= "";
1568 pp_string (pp
, "MEM[");
1570 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1572 pp_string (pp
, sep
);
1574 pp_string (pp
, "symbol: ");
1575 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1580 pp_string (pp
, sep
);
1582 pp_string (pp
, "base: ");
1583 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1585 tmp
= TMR_INDEX2 (node
);
1588 pp_string (pp
, sep
);
1590 pp_string (pp
, "base: ");
1591 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1593 tmp
= TMR_INDEX (node
);
1596 pp_string (pp
, sep
);
1598 pp_string (pp
, "index: ");
1599 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1601 tmp
= TMR_STEP (node
);
1604 pp_string (pp
, sep
);
1606 pp_string (pp
, "step: ");
1607 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1609 tmp
= TMR_OFFSET (node
);
1612 pp_string (pp
, sep
);
1614 pp_string (pp
, "offset: ");
1615 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1617 pp_right_bracket (pp
);
1625 /* Print the innermost component type. */
1626 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1627 tmp
= TREE_TYPE (tmp
))
1629 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1631 /* Print the dimensions. */
1632 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1633 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1639 case QUAL_UNION_TYPE
:
1641 unsigned int quals
= TYPE_QUALS (node
);
1643 if (quals
& TYPE_QUAL_ATOMIC
)
1644 pp_string (pp
, "atomic ");
1645 if (quals
& TYPE_QUAL_CONST
)
1646 pp_string (pp
, "const ");
1647 if (quals
& TYPE_QUAL_VOLATILE
)
1648 pp_string (pp
, "volatile ");
1650 /* Print the name of the structure. */
1651 if (TREE_CODE (node
) == RECORD_TYPE
)
1652 pp_string (pp
, "struct ");
1653 else if (TREE_CODE (node
) == UNION_TYPE
)
1654 pp_string (pp
, "union ");
1656 if (TYPE_NAME (node
))
1657 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1658 else if (!(flags
& TDF_SLIM
))
1659 /* FIXME: If we eliminate the 'else' above and attempt
1660 to show the fields for named types, we may get stuck
1661 following a cycle of pointers to structs. The alleged
1662 self-reference check in print_struct_decl will not detect
1663 cycles involving more than one pointer or struct type. */
1664 print_struct_decl (pp
, node
, spc
, flags
);
1673 if (flags
& TDF_GIMPLE
1674 && (POINTER_TYPE_P (TREE_TYPE (node
))
1675 || (TYPE_PRECISION (TREE_TYPE (node
))
1676 < TYPE_PRECISION (integer_type_node
))
1677 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1679 pp_string (pp
, "_Literal (");
1680 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1681 pp_string (pp
, ") ");
1683 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
1684 && ! (flags
& TDF_GIMPLE
))
1686 /* In the case of a pointer, one may want to divide by the
1687 size of the pointed-to type. Unfortunately, this not
1688 straightforward. The C front-end maps expressions
1693 in such a way that the two INTEGER_CST nodes for "5" have
1694 different values but identical types. In the latter
1695 case, the 5 is multiplied by sizeof (int) in c-common.c
1696 (pointer_int_sum) to convert it to a byte address, and
1697 yet the type of the node is left unchanged. Argh. What
1698 is consistent though is that the number value corresponds
1699 to bytes (UNITS) offset.
1701 NB: Neither of the following divisors can be trivially
1702 used to recover the original literal:
1704 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1705 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1706 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1707 pp_string (pp
, "B"); /* pseudo-unit */
1709 else if (tree_fits_shwi_p (node
))
1710 pp_wide_integer (pp
, tree_to_shwi (node
));
1711 else if (tree_fits_uhwi_p (node
))
1712 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1715 wide_int val
= wi::to_wide (node
);
1717 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1722 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
1723 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
1725 if ((flags
& TDF_GIMPLE
)
1726 && ! (POINTER_TYPE_P (TREE_TYPE (node
))
1727 || (TYPE_PRECISION (TREE_TYPE (node
))
1728 < TYPE_PRECISION (integer_type_node
))
1729 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1731 if (TYPE_UNSIGNED (TREE_TYPE (node
)))
1732 pp_character (pp
, 'u');
1733 if (TYPE_PRECISION (TREE_TYPE (node
))
1734 == TYPE_PRECISION (unsigned_type_node
))
1736 else if (TYPE_PRECISION (TREE_TYPE (node
))
1737 == TYPE_PRECISION (long_unsigned_type_node
))
1738 pp_character (pp
, 'l');
1739 else if (TYPE_PRECISION (TREE_TYPE (node
))
1740 == TYPE_PRECISION (long_long_unsigned_type_node
))
1741 pp_string (pp
, "ll");
1743 if (TREE_OVERFLOW (node
))
1744 pp_string (pp
, "(OVF)");
1748 /* Code copied from print_node. */
1751 if (TREE_OVERFLOW (node
))
1752 pp_string (pp
, " overflow");
1754 d
= TREE_REAL_CST (node
);
1755 if (REAL_VALUE_ISINF (d
))
1756 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1757 else if (REAL_VALUE_ISNAN (d
))
1758 pp_string (pp
, " Nan");
1762 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1763 pp_string (pp
, string
);
1771 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1772 pp_string (pp
, string
);
1777 pp_string (pp
, "__complex__ (");
1778 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
1779 pp_string (pp
, ", ");
1780 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
1781 pp_right_paren (pp
);
1785 pp_string (pp
, "\"");
1786 pretty_print_string (pp
, TREE_STRING_POINTER (node
));
1787 pp_string (pp
, "\"");
1793 pp_string (pp
, "{ ");
1794 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1797 pp_string (pp
, ", ");
1798 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
1801 pp_string (pp
, " }");
1807 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1809 if (TREE_CODE (node
) == METHOD_TYPE
)
1811 if (TYPE_METHOD_BASETYPE (node
))
1812 dump_decl_name (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1815 pp_string (pp
, "<null method basetype>");
1816 pp_colon_colon (pp
);
1818 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1819 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1820 else if (flags
& TDF_NOUID
)
1821 pp_printf (pp
, "<Txxxx>");
1823 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1824 dump_function_declaration (pp
, node
, spc
, flags
);
1829 dump_decl_name (pp
, node
, flags
);
1833 if (DECL_NAME (node
))
1834 dump_decl_name (pp
, node
, flags
);
1835 else if (LABEL_DECL_UID (node
) != -1)
1837 if (flags
& TDF_GIMPLE
)
1838 pp_printf (pp
, "L%d", (int) LABEL_DECL_UID (node
));
1840 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
1844 if (flags
& TDF_NOUID
)
1845 pp_string (pp
, "<D.xxxx>");
1848 if (flags
& TDF_GIMPLE
)
1849 pp_printf (pp
, "<D%u>", DECL_UID (node
));
1851 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
1857 if (DECL_IS_BUILTIN (node
))
1859 /* Don't print the declaration of built-in types. */
1862 if (DECL_NAME (node
))
1863 dump_decl_name (pp
, node
, flags
);
1864 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1866 pp_string (pp
, (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1867 ? "union" : "struct "));
1868 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1871 pp_string (pp
, "<anon>");
1877 case DEBUG_EXPR_DECL
:
1878 case NAMESPACE_DECL
:
1880 dump_decl_name (pp
, node
, flags
);
1884 pp_string (pp
, "<retval>");
1888 op0
= TREE_OPERAND (node
, 0);
1891 && (TREE_CODE (op0
) == INDIRECT_REF
1892 || (TREE_CODE (op0
) == MEM_REF
1893 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1894 && integer_zerop (TREE_OPERAND (op0
, 1))
1895 /* Dump the types of INTEGER_CSTs explicitly, for we
1896 can't infer them and MEM_ATTR caching will share
1897 MEM_REFs with differently-typed op0s. */
1898 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1899 /* Released SSA_NAMES have no TREE_TYPE. */
1900 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1901 /* Same pointer types, but ignoring POINTER_TYPE vs.
1903 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1904 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1905 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1906 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1907 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1908 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1909 /* Same value types ignoring qualifiers. */
1910 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1911 == TYPE_MAIN_VARIANT
1912 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
1913 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
1915 op0
= TREE_OPERAND (op0
, 0);
1918 if (op_prio (op0
) < op_prio (node
))
1920 dump_generic_node (pp
, op0
, spc
, flags
, false);
1921 if (op_prio (op0
) < op_prio (node
))
1922 pp_right_paren (pp
);
1923 pp_string (pp
, str
);
1924 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1925 op0
= component_ref_field_offset (node
);
1926 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1928 pp_string (pp
, "{off: ");
1929 dump_generic_node (pp
, op0
, spc
, flags
, false);
1930 pp_right_brace (pp
);
1935 pp_string (pp
, "BIT_FIELD_REF <");
1936 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1937 pp_string (pp
, ", ");
1938 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1939 pp_string (pp
, ", ");
1940 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1944 case BIT_INSERT_EXPR
:
1945 pp_string (pp
, "BIT_INSERT_EXPR <");
1946 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1947 pp_string (pp
, ", ");
1948 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1949 pp_string (pp
, ", ");
1950 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1951 pp_string (pp
, " (");
1952 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
1954 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
1956 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
1958 pp_string (pp
, " bits)>");
1962 case ARRAY_RANGE_REF
:
1963 op0
= TREE_OPERAND (node
, 0);
1964 if (op_prio (op0
) < op_prio (node
))
1966 dump_generic_node (pp
, op0
, spc
, flags
, false);
1967 if (op_prio (op0
) < op_prio (node
))
1968 pp_right_paren (pp
);
1969 pp_left_bracket (pp
);
1970 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1971 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1972 pp_string (pp
, " ...");
1973 pp_right_bracket (pp
);
1975 op0
= array_ref_low_bound (node
);
1976 op1
= array_ref_element_size (node
);
1978 if (!integer_zerop (op0
)
1979 || TREE_OPERAND (node
, 2)
1980 || TREE_OPERAND (node
, 3))
1982 pp_string (pp
, "{lb: ");
1983 dump_generic_node (pp
, op0
, spc
, flags
, false);
1984 pp_string (pp
, " sz: ");
1985 dump_generic_node (pp
, op1
, spc
, flags
, false);
1986 pp_right_brace (pp
);
1992 unsigned HOST_WIDE_INT ix
;
1994 bool is_struct_init
= false;
1995 bool is_array_init
= false;
1998 if (TREE_CLOBBER_P (node
))
1999 pp_string (pp
, "CLOBBER");
2000 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
2001 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
2002 is_struct_init
= true;
2003 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
2004 && TYPE_DOMAIN (TREE_TYPE (node
))
2005 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
2006 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
2009 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
2010 is_array_init
= true;
2011 curidx
= wi::to_widest (minv
);
2013 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
2020 dump_generic_node (pp
, field
, spc
, flags
, false);
2023 else if (is_array_init
2024 && (TREE_CODE (field
) != INTEGER_CST
2025 || curidx
!= wi::to_widest (field
)))
2027 pp_left_bracket (pp
);
2028 if (TREE_CODE (field
) == RANGE_EXPR
)
2030 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
2032 pp_string (pp
, " ... ");
2033 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
2035 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
2036 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
2039 dump_generic_node (pp
, field
, spc
, flags
, false);
2040 if (TREE_CODE (field
) == INTEGER_CST
)
2041 curidx
= wi::to_widest (field
);
2042 pp_string (pp
, "]=");
2047 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
2048 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
2049 val
= TREE_OPERAND (val
, 0);
2050 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
2051 dump_decl_name (pp
, val
, flags
);
2053 dump_generic_node (pp
, val
, spc
, flags
, false);
2054 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2060 pp_right_brace (pp
);
2067 if (flags
& TDF_SLIM
)
2069 pp_string (pp
, "<COMPOUND_EXPR>");
2073 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2074 spc
, flags
, !(flags
& TDF_SLIM
));
2075 if (flags
& TDF_SLIM
)
2076 newline_and_indent (pp
, spc
);
2083 for (tp
= &TREE_OPERAND (node
, 1);
2084 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2085 tp
= &TREE_OPERAND (*tp
, 1))
2087 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2088 spc
, flags
, !(flags
& TDF_SLIM
));
2089 if (flags
& TDF_SLIM
)
2090 newline_and_indent (pp
, spc
);
2098 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2102 case STATEMENT_LIST
:
2104 tree_stmt_iterator si
;
2107 if (flags
& TDF_SLIM
)
2109 pp_string (pp
, "<STATEMENT_LIST>");
2113 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2116 newline_and_indent (pp
, spc
);
2119 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2126 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2131 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2136 pp_string (pp
, "TARGET_EXPR <");
2137 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2140 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2145 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2150 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2152 pp_string (pp
, "if (");
2153 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2154 pp_right_paren (pp
);
2155 /* The lowered cond_exprs should always be printed in full. */
2156 if (COND_EXPR_THEN (node
)
2157 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2158 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2159 && COND_EXPR_ELSE (node
)
2160 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2161 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2164 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2166 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2168 pp_string (pp
, " else ");
2169 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2173 else if (!(flags
& TDF_SLIM
))
2175 /* Output COND_EXPR_THEN. */
2176 if (COND_EXPR_THEN (node
))
2178 newline_and_indent (pp
, spc
+2);
2180 newline_and_indent (pp
, spc
+4);
2181 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2183 newline_and_indent (pp
, spc
+2);
2184 pp_right_brace (pp
);
2187 /* Output COND_EXPR_ELSE. */
2188 if (COND_EXPR_ELSE (node
)
2189 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2191 newline_and_indent (pp
, spc
);
2192 pp_string (pp
, "else");
2193 newline_and_indent (pp
, spc
+2);
2195 newline_and_indent (pp
, spc
+4);
2196 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2198 newline_and_indent (pp
, spc
+2);
2199 pp_right_brace (pp
);
2206 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2210 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2214 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2220 if (!(flags
& TDF_SLIM
))
2222 if (BIND_EXPR_VARS (node
))
2226 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2228 print_declaration (pp
, op0
, spc
+2, flags
);
2233 newline_and_indent (pp
, spc
+2);
2234 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2235 newline_and_indent (pp
, spc
);
2236 pp_right_brace (pp
);
2242 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2243 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2245 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2247 /* Print parameters. */
2252 call_expr_arg_iterator iter
;
2253 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2255 dump_generic_node (pp
, arg
, spc
, flags
, false);
2256 if (more_call_expr_args_p (&iter
))
2263 if (CALL_EXPR_VA_ARG_PACK (node
))
2265 if (call_expr_nargs (node
) > 0)
2270 pp_string (pp
, "__builtin_va_arg_pack ()");
2272 pp_right_paren (pp
);
2274 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2277 pp_string (pp
, " [static-chain: ");
2278 dump_generic_node (pp
, op1
, spc
, flags
, false);
2279 pp_right_bracket (pp
);
2282 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2283 pp_string (pp
, " [return slot optimization]");
2284 if (CALL_EXPR_TAILCALL (node
))
2285 pp_string (pp
, " [tail call]");
2288 case WITH_CLEANUP_EXPR
:
2292 case CLEANUP_POINT_EXPR
:
2293 pp_string (pp
, "<<cleanup_point ");
2294 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2295 pp_string (pp
, ">>");
2298 case PLACEHOLDER_EXPR
:
2299 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2300 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2304 /* Binary arithmetic and logic expressions. */
2305 case WIDEN_SUM_EXPR
:
2306 case WIDEN_MULT_EXPR
:
2308 case MULT_HIGHPART_EXPR
:
2310 case POINTER_PLUS_EXPR
:
2312 case TRUNC_DIV_EXPR
:
2314 case FLOOR_DIV_EXPR
:
2315 case ROUND_DIV_EXPR
:
2316 case TRUNC_MOD_EXPR
:
2318 case FLOOR_MOD_EXPR
:
2319 case ROUND_MOD_EXPR
:
2321 case EXACT_DIV_EXPR
:
2326 case WIDEN_LSHIFT_EXPR
:
2330 case TRUTH_ANDIF_EXPR
:
2331 case TRUTH_ORIF_EXPR
:
2332 case TRUTH_AND_EXPR
:
2334 case TRUTH_XOR_EXPR
:
2348 case UNORDERED_EXPR
:
2350 const char *op
= op_symbol (node
);
2351 op0
= TREE_OPERAND (node
, 0);
2352 op1
= TREE_OPERAND (node
, 1);
2354 /* When the operands are expressions with less priority,
2355 keep semantics of the tree representation. */
2356 if (op_prio (op0
) <= op_prio (node
))
2359 dump_generic_node (pp
, op0
, spc
, flags
, false);
2360 pp_right_paren (pp
);
2363 dump_generic_node (pp
, op0
, spc
, flags
, false);
2369 /* When the operands are expressions with less priority,
2370 keep semantics of the tree representation. */
2371 if (op_prio (op1
) <= op_prio (node
))
2374 dump_generic_node (pp
, op1
, spc
, flags
, false);
2375 pp_right_paren (pp
);
2378 dump_generic_node (pp
, op1
, spc
, flags
, false);
2382 /* Unary arithmetic and logic expressions. */
2385 case TRUTH_NOT_EXPR
:
2387 case PREDECREMENT_EXPR
:
2388 case PREINCREMENT_EXPR
:
2390 if (TREE_CODE (node
) == ADDR_EXPR
2391 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2392 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2393 ; /* Do not output '&' for strings and function pointers. */
2395 pp_string (pp
, op_symbol (node
));
2397 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2400 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2401 pp_right_paren (pp
);
2404 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2407 case POSTDECREMENT_EXPR
:
2408 case POSTINCREMENT_EXPR
:
2409 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2412 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2413 pp_right_paren (pp
);
2416 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2417 pp_string (pp
, op_symbol (node
));
2421 pp_string (pp
, "MIN_EXPR <");
2422 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2423 pp_string (pp
, ", ");
2424 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2429 pp_string (pp
, "MAX_EXPR <");
2430 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2431 pp_string (pp
, ", ");
2432 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2437 pp_string (pp
, "ABS_EXPR <");
2438 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2446 case ADDR_SPACE_CONVERT_EXPR
:
2447 case FIXED_CONVERT_EXPR
:
2448 case FIX_TRUNC_EXPR
:
2451 type
= TREE_TYPE (node
);
2452 op0
= TREE_OPERAND (node
, 0);
2453 if (type
!= TREE_TYPE (op0
))
2456 dump_generic_node (pp
, type
, spc
, flags
, false);
2457 pp_string (pp
, ") ");
2459 if (op_prio (op0
) < op_prio (node
))
2461 dump_generic_node (pp
, op0
, spc
, flags
, false);
2462 if (op_prio (op0
) < op_prio (node
))
2463 pp_right_paren (pp
);
2466 case VIEW_CONVERT_EXPR
:
2467 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2468 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2469 pp_string (pp
, ">(");
2470 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2471 pp_right_paren (pp
);
2475 pp_string (pp
, "((");
2476 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2477 pp_string (pp
, "))");
2480 case NON_LVALUE_EXPR
:
2481 pp_string (pp
, "NON_LVALUE_EXPR <");
2482 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2487 pp_string (pp
, "SAVE_EXPR <");
2488 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2493 pp_string (pp
, "COMPLEX_EXPR <");
2494 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2495 pp_string (pp
, ", ");
2496 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2501 pp_string (pp
, "CONJ_EXPR <");
2502 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2507 if (flags
& TDF_GIMPLE
)
2509 pp_string (pp
, "__real ");
2510 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2514 pp_string (pp
, "REALPART_EXPR <");
2515 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2521 if (flags
& TDF_GIMPLE
)
2523 pp_string (pp
, "__imag ");
2524 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2528 pp_string (pp
, "IMAGPART_EXPR <");
2529 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2535 pp_string (pp
, "VA_ARG_EXPR <");
2536 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2540 case TRY_FINALLY_EXPR
:
2541 case TRY_CATCH_EXPR
:
2542 pp_string (pp
, "try");
2543 newline_and_indent (pp
, spc
+2);
2545 newline_and_indent (pp
, spc
+4);
2546 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2547 newline_and_indent (pp
, spc
+2);
2548 pp_right_brace (pp
);
2549 newline_and_indent (pp
, spc
);
2551 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2552 newline_and_indent (pp
, spc
+2);
2554 newline_and_indent (pp
, spc
+4);
2555 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2556 newline_and_indent (pp
, spc
+2);
2557 pp_right_brace (pp
);
2562 pp_string (pp
, "catch (");
2563 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2564 pp_right_paren (pp
);
2565 newline_and_indent (pp
, spc
+2);
2567 newline_and_indent (pp
, spc
+4);
2568 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2569 newline_and_indent (pp
, spc
+2);
2570 pp_right_brace (pp
);
2574 case EH_FILTER_EXPR
:
2575 pp_string (pp
, "<<<eh_filter (");
2576 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2577 pp_string (pp
, ")>>>");
2578 newline_and_indent (pp
, spc
+2);
2580 newline_and_indent (pp
, spc
+4);
2581 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2582 newline_and_indent (pp
, spc
+2);
2583 pp_right_brace (pp
);
2588 op0
= TREE_OPERAND (node
, 0);
2589 /* If this is for break or continue, don't bother printing it. */
2590 if (DECL_NAME (op0
))
2592 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2593 if (strcmp (name
, "break") == 0
2594 || strcmp (name
, "continue") == 0)
2597 dump_generic_node (pp
, op0
, spc
, flags
, false);
2599 if (DECL_NONLOCAL (op0
))
2600 pp_string (pp
, " [non-local]");
2604 pp_string (pp
, "while (1)");
2605 if (!(flags
& TDF_SLIM
))
2607 newline_and_indent (pp
, spc
+2);
2609 newline_and_indent (pp
, spc
+4);
2610 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2611 newline_and_indent (pp
, spc
+2);
2612 pp_right_brace (pp
);
2618 pp_string (pp
, "// predicted ");
2619 if (PREDICT_EXPR_OUTCOME (node
))
2620 pp_string (pp
, "likely by ");
2622 pp_string (pp
, "unlikely by ");
2623 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2624 pp_string (pp
, " predictor.");
2628 pp_string (pp
, "ANNOTATE_EXPR <");
2629 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2630 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2632 case annot_expr_ivdep_kind
:
2633 pp_string (pp
, ", ivdep");
2635 case annot_expr_no_vector_kind
:
2636 pp_string (pp
, ", no-vector");
2638 case annot_expr_vector_kind
:
2639 pp_string (pp
, ", vector");
2648 pp_string (pp
, "return");
2649 op0
= TREE_OPERAND (node
, 0);
2653 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2654 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2657 dump_generic_node (pp
, op0
, spc
, flags
, false);
2662 pp_string (pp
, "if (");
2663 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2664 pp_string (pp
, ") break");
2668 pp_string (pp
, "switch (");
2669 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2670 pp_right_paren (pp
);
2671 if (!(flags
& TDF_SLIM
))
2673 newline_and_indent (pp
, spc
+2);
2675 if (SWITCH_BODY (node
))
2677 newline_and_indent (pp
, spc
+4);
2678 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2683 tree vec
= SWITCH_LABELS (node
);
2684 size_t i
, n
= TREE_VEC_LENGTH (vec
);
2685 for (i
= 0; i
< n
; ++i
)
2687 tree elt
= TREE_VEC_ELT (vec
, i
);
2688 newline_and_indent (pp
, spc
+4);
2691 dump_generic_node (pp
, elt
, spc
+4, flags
, false);
2692 pp_string (pp
, " goto ");
2693 dump_generic_node (pp
, CASE_LABEL (elt
), spc
+4,
2698 pp_string (pp
, "case ???: goto ???;");
2701 newline_and_indent (pp
, spc
+2);
2702 pp_right_brace (pp
);
2708 op0
= GOTO_DESTINATION (node
);
2709 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2711 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2712 if (strcmp (name
, "break") == 0
2713 || strcmp (name
, "continue") == 0)
2715 pp_string (pp
, name
);
2719 pp_string (pp
, "goto ");
2720 dump_generic_node (pp
, op0
, spc
, flags
, false);
2724 pp_string (pp
, "__asm__");
2725 if (ASM_VOLATILE_P (node
))
2726 pp_string (pp
, " __volatile__");
2728 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2730 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2732 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2733 if (ASM_CLOBBERS (node
))
2736 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2738 pp_right_paren (pp
);
2741 case CASE_LABEL_EXPR
:
2742 if (CASE_LOW (node
) && CASE_HIGH (node
))
2744 pp_string (pp
, "case ");
2745 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2746 pp_string (pp
, " ... ");
2747 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2749 else if (CASE_LOW (node
))
2751 pp_string (pp
, "case ");
2752 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2755 pp_string (pp
, "default");
2760 pp_string (pp
, "OBJ_TYPE_REF(");
2761 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2763 /* We omit the class type for -fcompare-debug because we may
2764 drop TYPE_BINFO early depending on debug info, and then
2765 virtual_method_call_p would return false, whereas when
2766 TYPE_BINFO is preserved it may still return true and then
2767 we'd print the class type. Compare tree and rtl dumps for
2768 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
2769 for example, at occurrences of OBJ_TYPE_REF. */
2770 if (!(flags
& (TDF_SLIM
| TDF_COMPARE_DEBUG
))
2771 && virtual_method_call_p (node
))
2773 pp_string (pp
, "(");
2774 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2775 pp_string (pp
, ")");
2777 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2779 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2780 pp_right_paren (pp
);
2784 if (SSA_NAME_IDENTIFIER (node
))
2786 if ((flags
& TDF_NOUID
)
2787 && SSA_NAME_VAR (node
)
2788 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
2789 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
2790 else if (! (flags
& TDF_GIMPLE
)
2791 || SSA_NAME_VAR (node
))
2792 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2796 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2797 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2798 pp_string (pp
, "(D)");
2799 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2800 pp_string (pp
, "(ab)");
2803 case WITH_SIZE_EXPR
:
2804 pp_string (pp
, "WITH_SIZE_EXPR <");
2805 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2806 pp_string (pp
, ", ");
2807 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2812 pp_string (pp
, "ASSERT_EXPR <");
2813 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2814 pp_string (pp
, ", ");
2815 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2820 pp_string (pp
, "scev_known");
2823 case SCEV_NOT_KNOWN
:
2824 pp_string (pp
, "scev_not_known");
2827 case POLYNOMIAL_CHREC
:
2829 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2830 pp_string (pp
, ", +, ");
2831 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2832 pp_printf (pp
, "}_%u", CHREC_VARIABLE (node
));
2836 case REALIGN_LOAD_EXPR
:
2837 pp_string (pp
, "REALIGN_LOAD <");
2838 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2839 pp_string (pp
, ", ");
2840 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2841 pp_string (pp
, ", ");
2842 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2847 pp_string (pp
, " VEC_COND_EXPR < ");
2848 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2849 pp_string (pp
, " , ");
2850 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2851 pp_string (pp
, " , ");
2852 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2853 pp_string (pp
, " > ");
2857 pp_string (pp
, " VEC_PERM_EXPR < ");
2858 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2859 pp_string (pp
, " , ");
2860 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2861 pp_string (pp
, " , ");
2862 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2863 pp_string (pp
, " > ");
2867 pp_string (pp
, " DOT_PROD_EXPR < ");
2868 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2869 pp_string (pp
, ", ");
2870 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2871 pp_string (pp
, ", ");
2872 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2873 pp_string (pp
, " > ");
2876 case WIDEN_MULT_PLUS_EXPR
:
2877 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
2878 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2879 pp_string (pp
, ", ");
2880 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2881 pp_string (pp
, ", ");
2882 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2883 pp_string (pp
, " > ");
2886 case WIDEN_MULT_MINUS_EXPR
:
2887 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
2888 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2889 pp_string (pp
, ", ");
2890 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2891 pp_string (pp
, ", ");
2892 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2893 pp_string (pp
, " > ");
2897 pp_string (pp
, " FMA_EXPR < ");
2898 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2899 pp_string (pp
, ", ");
2900 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2901 pp_string (pp
, ", ");
2902 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2903 pp_string (pp
, " > ");
2907 pp_string (pp
, "#pragma acc parallel");
2908 goto dump_omp_clauses_body
;
2911 pp_string (pp
, "#pragma acc kernels");
2912 goto dump_omp_clauses_body
;
2915 pp_string (pp
, "#pragma acc data");
2916 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2919 case OACC_HOST_DATA
:
2920 pp_string (pp
, "#pragma acc host_data");
2921 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2925 pp_string (pp
, "#pragma acc declare");
2926 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2930 pp_string (pp
, "#pragma acc update");
2931 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2934 case OACC_ENTER_DATA
:
2935 pp_string (pp
, "#pragma acc enter data");
2936 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2939 case OACC_EXIT_DATA
:
2940 pp_string (pp
, "#pragma acc exit data");
2941 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2945 pp_string (pp
, "#pragma acc cache");
2946 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2950 pp_string (pp
, "#pragma omp parallel");
2951 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2954 dump_omp_clauses_body
:
2955 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2959 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2961 newline_and_indent (pp
, spc
+ 2);
2963 newline_and_indent (pp
, spc
+ 4);
2964 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2965 newline_and_indent (pp
, spc
+ 2);
2966 pp_right_brace (pp
);
2972 pp_string (pp
, "#pragma omp task");
2973 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2977 pp_string (pp
, "#pragma omp for");
2981 pp_string (pp
, "#pragma omp simd");
2985 pp_string (pp
, "#pragma simd");
2989 /* This label points one line after dumping the clauses.
2990 For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2991 parameters are printed out. */
2992 goto dump_omp_loop_cilk_for
;
2994 case OMP_DISTRIBUTE
:
2995 pp_string (pp
, "#pragma omp distribute");
2999 pp_string (pp
, "#pragma omp taskloop");
3003 pp_string (pp
, "#pragma acc loop");
3007 pp_string (pp
, "#pragma omp teams");
3008 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
3011 case OMP_TARGET_DATA
:
3012 pp_string (pp
, "#pragma omp target data");
3013 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
3016 case OMP_TARGET_ENTER_DATA
:
3017 pp_string (pp
, "#pragma omp target enter data");
3018 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3022 case OMP_TARGET_EXIT_DATA
:
3023 pp_string (pp
, "#pragma omp target exit data");
3024 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3029 pp_string (pp
, "#pragma omp target");
3030 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3033 case OMP_TARGET_UPDATE
:
3034 pp_string (pp
, "#pragma omp target update");
3035 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3040 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3042 dump_omp_loop_cilk_for
:
3043 if (!(flags
& TDF_SLIM
))
3047 if (OMP_FOR_PRE_BODY (node
))
3049 if (TREE_CODE (node
) == CILK_FOR
)
3050 pp_string (pp
, " ");
3052 newline_and_indent (pp
, spc
+ 2);
3055 newline_and_indent (pp
, spc
);
3056 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3059 if (OMP_FOR_INIT (node
))
3062 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3065 if (TREE_CODE (node
) != CILK_FOR
|| OMP_FOR_PRE_BODY (node
))
3066 newline_and_indent (pp
, spc
);
3067 if (TREE_CODE (node
) == CILK_FOR
)
3068 pp_string (pp
, "_Cilk_for (");
3070 pp_string (pp
, "for (");
3071 dump_generic_node (pp
,
3072 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
3074 pp_string (pp
, "; ");
3075 dump_generic_node (pp
,
3076 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
3078 pp_string (pp
, "; ");
3079 dump_generic_node (pp
,
3080 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3082 pp_right_paren (pp
);
3084 if (TREE_CODE (node
) == CILK_FOR
)
3085 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3087 if (OMP_FOR_BODY (node
))
3089 newline_and_indent (pp
, spc
+ 2);
3091 newline_and_indent (pp
, spc
+ 4);
3092 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3094 newline_and_indent (pp
, spc
+ 2);
3095 pp_right_brace (pp
);
3097 if (OMP_FOR_INIT (node
))
3098 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3099 if (OMP_FOR_PRE_BODY (node
))
3102 newline_and_indent (pp
, spc
+ 2);
3103 pp_right_brace (pp
);
3110 pp_string (pp
, "#pragma omp sections");
3111 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3115 pp_string (pp
, "#pragma omp section");
3119 pp_string (pp
, "#pragma omp master");
3123 pp_string (pp
, "#pragma omp taskgroup");
3127 pp_string (pp
, "#pragma omp ordered");
3128 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3132 pp_string (pp
, "#pragma omp critical");
3133 if (OMP_CRITICAL_NAME (node
))
3137 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3139 pp_right_paren (pp
);
3141 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3145 pp_string (pp
, "#pragma omp atomic");
3146 if (OMP_ATOMIC_SEQ_CST (node
))
3147 pp_string (pp
, " seq_cst");
3148 newline_and_indent (pp
, spc
+ 2);
3149 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3153 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3156 case OMP_ATOMIC_READ
:
3157 pp_string (pp
, "#pragma omp atomic read");
3158 if (OMP_ATOMIC_SEQ_CST (node
))
3159 pp_string (pp
, " seq_cst");
3160 newline_and_indent (pp
, spc
+ 2);
3161 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3165 case OMP_ATOMIC_CAPTURE_OLD
:
3166 case OMP_ATOMIC_CAPTURE_NEW
:
3167 pp_string (pp
, "#pragma omp atomic capture");
3168 if (OMP_ATOMIC_SEQ_CST (node
))
3169 pp_string (pp
, " seq_cst");
3170 newline_and_indent (pp
, spc
+ 2);
3171 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3175 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3179 pp_string (pp
, "#pragma omp single");
3180 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3184 dump_omp_clause (pp
, node
, spc
, flags
);
3188 case TRANSACTION_EXPR
:
3189 if (TRANSACTION_EXPR_OUTER (node
))
3190 pp_string (pp
, "__transaction_atomic [[outer]]");
3191 else if (TRANSACTION_EXPR_RELAXED (node
))
3192 pp_string (pp
, "__transaction_relaxed");
3194 pp_string (pp
, "__transaction_atomic");
3195 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3197 newline_and_indent (pp
, spc
);
3199 newline_and_indent (pp
, spc
+ 2);
3200 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3201 spc
+ 2, flags
, false);
3202 newline_and_indent (pp
, spc
);
3203 pp_right_brace (pp
);
3208 case REDUC_MAX_EXPR
:
3209 pp_string (pp
, " REDUC_MAX_EXPR < ");
3210 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3211 pp_string (pp
, " > ");
3214 case REDUC_MIN_EXPR
:
3215 pp_string (pp
, " REDUC_MIN_EXPR < ");
3216 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3217 pp_string (pp
, " > ");
3220 case REDUC_PLUS_EXPR
:
3221 pp_string (pp
, " REDUC_PLUS_EXPR < ");
3222 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3223 pp_string (pp
, " > ");
3226 case VEC_WIDEN_MULT_HI_EXPR
:
3227 case VEC_WIDEN_MULT_LO_EXPR
:
3228 case VEC_WIDEN_MULT_EVEN_EXPR
:
3229 case VEC_WIDEN_MULT_ODD_EXPR
:
3230 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3231 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3233 for (str
= get_tree_code_name (code
); *str
; str
++)
3234 pp_character (pp
, TOUPPER (*str
));
3235 pp_string (pp
, " < ");
3236 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3237 pp_string (pp
, ", ");
3238 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3239 pp_string (pp
, " > ");
3242 case VEC_UNPACK_HI_EXPR
:
3243 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3244 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3245 pp_string (pp
, " > ");
3248 case VEC_UNPACK_LO_EXPR
:
3249 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3250 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3251 pp_string (pp
, " > ");
3254 case VEC_UNPACK_FLOAT_HI_EXPR
:
3255 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3256 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3257 pp_string (pp
, " > ");
3260 case VEC_UNPACK_FLOAT_LO_EXPR
:
3261 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3262 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3263 pp_string (pp
, " > ");
3266 case VEC_PACK_TRUNC_EXPR
:
3267 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3268 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3269 pp_string (pp
, ", ");
3270 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3271 pp_string (pp
, " > ");
3274 case VEC_PACK_SAT_EXPR
:
3275 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3276 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3277 pp_string (pp
, ", ");
3278 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3279 pp_string (pp
, " > ");
3282 case VEC_PACK_FIX_TRUNC_EXPR
:
3283 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3284 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3285 pp_string (pp
, ", ");
3286 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3287 pp_string (pp
, " > ");
3291 dump_block_node (pp
, node
, spc
, flags
);
3294 case CILK_SPAWN_STMT
:
3295 pp_string (pp
, "_Cilk_spawn ");
3296 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3299 case CILK_SYNC_STMT
:
3300 pp_string (pp
, "_Cilk_sync");
3307 if (is_stmt
&& is_expr
)
3313 /* Print the declaration of a variable. */
3316 print_declaration (pretty_printer
*pp
, tree t
, int spc
, dump_flags_t flags
)
3320 if (TREE_CODE(t
) == NAMELIST_DECL
)
3322 pp_string(pp
, "namelist ");
3323 dump_decl_name (pp
, t
, flags
);
3328 if (TREE_CODE (t
) == TYPE_DECL
)
3329 pp_string (pp
, "typedef ");
3331 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3332 pp_string (pp
, "register ");
3334 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3335 pp_string (pp
, "extern ");
3336 else if (TREE_STATIC (t
))
3337 pp_string (pp
, "static ");
3339 /* Print the type and name. */
3340 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3344 /* Print array's type. */
3345 tmp
= TREE_TYPE (t
);
3346 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3347 tmp
= TREE_TYPE (tmp
);
3348 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3350 /* Print variable's name. */
3352 dump_generic_node (pp
, t
, spc
, flags
, false);
3354 /* Print the dimensions. */
3355 tmp
= TREE_TYPE (t
);
3356 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3358 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3359 tmp
= TREE_TYPE (tmp
);
3362 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3364 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3366 dump_decl_name (pp
, t
, flags
);
3367 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3371 /* Print type declaration. */
3372 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3374 /* Print variable's name. */
3376 dump_generic_node (pp
, t
, spc
, flags
, false);
3379 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
3381 pp_string (pp
, " __asm__ ");
3383 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3384 pp_right_paren (pp
);
3387 /* The initial value of a function serves to determine whether the function
3388 is declared or defined. So the following does not apply to function
3390 if (TREE_CODE (t
) != FUNCTION_DECL
)
3392 /* Print the initial value. */
3393 if (DECL_INITIAL (t
))
3398 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3402 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3404 pp_string (pp
, " [value-expr: ");
3405 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3406 pp_right_bracket (pp
);
3413 /* Prints a structure: name, fields, and methods.
3414 FIXME: Still incomplete. */
3417 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
3420 /* Print the name of the structure. */
3421 if (TYPE_NAME (node
))
3424 if (TREE_CODE (node
) == RECORD_TYPE
)
3425 pp_string (pp
, "struct ");
3426 else if ((TREE_CODE (node
) == UNION_TYPE
3427 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3428 pp_string (pp
, "union ");
3430 dump_generic_node (pp
, TYPE_NAME (node
), spc
, 0, false);
3433 /* Print the contents of the structure. */
3439 /* Print the fields of the structure. */
3442 tmp
= TYPE_FIELDS (node
);
3445 /* Avoid to print recursively the structure. */
3446 /* FIXME : Not implemented correctly...,
3447 what about the case when we have a cycle in the contain graph? ...
3448 Maybe this could be solved by looking at the scope in which the
3449 structure was declared. */
3450 if (TREE_TYPE (tmp
) != node
3451 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3452 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3454 print_declaration (pp
, tmp
, spc
+2, flags
);
3457 tmp
= DECL_CHAIN (tmp
);
3461 pp_right_brace (pp
);
3464 /* Return the priority of the operator CODE.
3466 From lowest to highest precedence with either left-to-right (L-R)
3467 or right-to-left (R-L) associativity]:
3470 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3482 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3483 15 [L-R] fn() [] -> .
3485 unary +, - and * have higher precedence than the corresponding binary
3489 op_code_prio (enum tree_code code
)
3506 case TRUTH_ORIF_EXPR
:
3509 case TRUTH_AND_EXPR
:
3510 case TRUTH_ANDIF_EXPR
:
3517 case TRUTH_XOR_EXPR
:
3534 case UNORDERED_EXPR
:
3545 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3546 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3547 case WIDEN_LSHIFT_EXPR
:
3550 case WIDEN_SUM_EXPR
:
3552 case POINTER_PLUS_EXPR
:
3556 case VEC_WIDEN_MULT_HI_EXPR
:
3557 case VEC_WIDEN_MULT_LO_EXPR
:
3558 case WIDEN_MULT_EXPR
:
3560 case WIDEN_MULT_PLUS_EXPR
:
3561 case WIDEN_MULT_MINUS_EXPR
:
3563 case MULT_HIGHPART_EXPR
:
3564 case TRUNC_DIV_EXPR
:
3566 case FLOOR_DIV_EXPR
:
3567 case ROUND_DIV_EXPR
:
3569 case EXACT_DIV_EXPR
:
3570 case TRUNC_MOD_EXPR
:
3572 case FLOOR_MOD_EXPR
:
3573 case ROUND_MOD_EXPR
:
3577 case TRUTH_NOT_EXPR
:
3579 case POSTINCREMENT_EXPR
:
3580 case POSTDECREMENT_EXPR
:
3581 case PREINCREMENT_EXPR
:
3582 case PREDECREMENT_EXPR
:
3588 case FIX_TRUNC_EXPR
:
3594 case ARRAY_RANGE_REF
:
3598 /* Special expressions. */
3604 case REDUC_MAX_EXPR
:
3605 case REDUC_MIN_EXPR
:
3606 case REDUC_PLUS_EXPR
:
3607 case VEC_UNPACK_HI_EXPR
:
3608 case VEC_UNPACK_LO_EXPR
:
3609 case VEC_UNPACK_FLOAT_HI_EXPR
:
3610 case VEC_UNPACK_FLOAT_LO_EXPR
:
3611 case VEC_PACK_TRUNC_EXPR
:
3612 case VEC_PACK_SAT_EXPR
:
3616 /* Return an arbitrarily high precedence to avoid surrounding single
3617 VAR_DECLs in ()s. */
3622 /* Return the priority of the operator OP. */
3625 op_prio (const_tree op
)
3627 enum tree_code code
;
3632 code
= TREE_CODE (op
);
3633 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3634 return op_prio (TREE_OPERAND (op
, 0));
3636 return op_code_prio (code
);
3639 /* Return the symbol associated with operator CODE. */
3642 op_symbol_code (enum tree_code code
)
3650 case TRUTH_ORIF_EXPR
:
3653 case TRUTH_AND_EXPR
:
3654 case TRUTH_ANDIF_EXPR
:
3660 case TRUTH_XOR_EXPR
:
3670 case UNORDERED_EXPR
:
3716 case WIDEN_LSHIFT_EXPR
:
3719 case POINTER_PLUS_EXPR
:
3725 case REDUC_PLUS_EXPR
:
3728 case WIDEN_SUM_EXPR
:
3731 case WIDEN_MULT_EXPR
:
3734 case MULT_HIGHPART_EXPR
:
3744 case TRUTH_NOT_EXPR
:
3751 case TRUNC_DIV_EXPR
:
3758 case FLOOR_DIV_EXPR
:
3761 case ROUND_DIV_EXPR
:
3764 case EXACT_DIV_EXPR
:
3767 case TRUNC_MOD_EXPR
:
3773 case FLOOR_MOD_EXPR
:
3776 case ROUND_MOD_EXPR
:
3779 case PREDECREMENT_EXPR
:
3782 case PREINCREMENT_EXPR
:
3785 case POSTDECREMENT_EXPR
:
3788 case POSTINCREMENT_EXPR
:
3798 return "<<< ??? >>>";
3802 /* Return the symbol associated with operator OP. */
3805 op_symbol (const_tree op
)
3807 return op_symbol_code (TREE_CODE (op
));
3810 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3811 the gimple_call_fn of a GIMPLE_CALL. */
3814 print_call_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
3818 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3819 op0
= TREE_OPERAND (op0
, 0);
3822 switch (TREE_CODE (op0
))
3827 dump_function_name (pp
, op0
, flags
);
3833 op0
= TREE_OPERAND (op0
, 0);
3838 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3839 pp_string (pp
, ") ? ");
3840 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3841 pp_string (pp
, " : ");
3842 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3846 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3847 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
3849 dump_generic_node (pp
, op0
, 0, flags
, false);
3853 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3855 op0
= TREE_OPERAND (op0
, 0);
3862 dump_generic_node (pp
, op0
, 0, flags
, false);
3870 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3873 pretty_print_string (pretty_printer
*pp
, const char *str
)
3883 pp_string (pp
, "\\b");
3887 pp_string (pp
, "\\f");
3891 pp_string (pp
, "\\n");
3895 pp_string (pp
, "\\r");
3899 pp_string (pp
, "\\t");
3903 pp_string (pp
, "\\v");
3907 pp_string (pp
, "\\\\");
3911 pp_string (pp
, "\\\"");
3915 pp_string (pp
, "\\'");
3918 /* No need to handle \0; the loop terminates on \0. */
3921 pp_string (pp
, "\\1");
3925 pp_string (pp
, "\\2");
3929 pp_string (pp
, "\\3");
3933 pp_string (pp
, "\\4");
3937 pp_string (pp
, "\\5");
3941 pp_string (pp
, "\\6");
3945 pp_string (pp
, "\\7");
3949 if (!ISPRINT (str
[0]))
3952 sprintf (buf
, "\\x%x", (unsigned char)str
[0]);
3953 pp_string (pp
, buf
);
3956 pp_character (pp
, str
[0]);
3964 maybe_init_pretty_print (FILE *file
)
3968 tree_pp
= new pretty_printer ();
3969 pp_needs_newline (tree_pp
) = true;
3970 pp_translate_identifiers (tree_pp
) = false;
3973 tree_pp
->buffer
->stream
= file
;
3977 newline_and_indent (pretty_printer
*pp
, int spc
)
3983 /* Handle the %K format for TEXT. Separate from default_tree_printer
3984 so it can also be used in front ends.
3985 Argument is a statement from which EXPR_LOCATION and TREE_BLOCK will
3989 percent_K_format (text_info
*text
, tree t
)
3991 text
->set_location (0, EXPR_LOCATION (t
), true);
3992 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3993 tree block
= TREE_BLOCK (t
);
3994 *pp_ti_abstract_origin (text
) = NULL
;
3998 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3999 representing the outermost block of an inlined function.
4000 So walk the BLOCK tree until we hit such a scope. */
4002 && TREE_CODE (block
) == BLOCK
)
4004 if (inlined_function_outer_scope_p (block
))
4006 *pp_ti_abstract_origin (text
) = block
;
4009 block
= BLOCK_SUPERCONTEXT (block
);
4015 && TREE_CODE (block
) == BLOCK
4016 && BLOCK_ABSTRACT_ORIGIN (block
))
4018 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
4020 while (TREE_CODE (ao
) == BLOCK
4021 && BLOCK_ABSTRACT_ORIGIN (ao
)
4022 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
4023 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
4025 if (TREE_CODE (ao
) == FUNCTION_DECL
)
4027 *pp_ti_abstract_origin (text
) = block
;
4030 block
= BLOCK_SUPERCONTEXT (block
);
4034 /* Print the identifier ID to PRETTY-PRINTER. */
4037 pp_tree_identifier (pretty_printer
*pp
, tree id
)
4039 if (pp_translate_identifiers (pp
))
4041 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
4042 pp_append_text (pp
, text
, text
+ strlen (text
));
4045 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
4046 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
4049 /* A helper function that is used to dump function information before the
4053 dump_function_header (FILE *dump_file
, tree fdecl
, dump_flags_t flags
)
4055 const char *dname
, *aname
;
4056 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
4057 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
4059 dname
= lang_hooks
.decl_printable_name (fdecl
, 1);
4061 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
4062 aname
= (IDENTIFIER_POINTER
4063 (DECL_ASSEMBLER_NAME (fdecl
)));
4065 aname
= "<unset-asm-name>";
4067 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
4068 dname
, aname
, fun
->funcdef_no
);
4069 if (!(flags
& TDF_NOUID
))
4070 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
4073 fprintf (dump_file
, ", cgraph_uid=%d", node
->uid
);
4074 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
4075 node
->frequency
== NODE_FREQUENCY_HOT
4077 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
4078 ? " (unlikely executed)"
4079 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
4080 ? " (executed once)"
4084 fprintf (dump_file
, ")\n\n");
4087 /* Dump double_int D to pretty_printer PP. UNS is true
4088 if D is unsigned and false otherwise. */
4090 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4093 pp_wide_integer (pp
, d
.low
);
4094 else if (d
.fits_uhwi ())
4095 pp_unsigned_wide_integer (pp
, d
.low
);
4098 unsigned HOST_WIDE_INT low
= d
.low
;
4099 HOST_WIDE_INT high
= d
.high
;
4100 if (!uns
&& d
.is_negative ())
4103 high
= ~high
+ !low
;
4106 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4108 sprintf (pp_buffer (pp
)->digit_buffer
,
4109 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4110 (unsigned HOST_WIDE_INT
) high
, low
);
4111 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);