1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2018 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
29 #include "tree-pretty-print.h"
30 #include "stor-layout.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
34 #include "internal-fn.h"
35 #include "gomp-constants.h"
38 /* Local functions, macros and variables. */
39 static const char *op_symbol (const_tree
);
40 static void pretty_print_string (pretty_printer
*, const char*, unsigned);
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 /* Print a single expression T to string, and return it. */
168 print_generic_expr_to_str (tree t
)
171 dump_generic_node (&pp
, t
, 0, TDF_VOPS
|TDF_MEMSYMS
, false);
172 return xstrdup (pp_formatted_text (&pp
));
175 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
176 in it are replaced with Dxxxx, as long as they are at the start or
177 preceded by $ and at the end or followed by $. See make_fancy_name
181 dump_fancy_name (pretty_printer
*pp
, tree name
)
184 int length
= IDENTIFIER_LENGTH (name
);
185 const char *n
= IDENTIFIER_POINTER (name
);
192 && (n
== IDENTIFIER_POINTER (name
) || n
[-1] == '$'))
195 while (ISDIGIT (n
[l
]))
197 if (n
[l
] == '\0' || n
[l
] == '$')
210 pp_tree_identifier (pp
, name
);
214 char *str
= XNEWVEC (char, length
+ 1);
217 q
= n
= IDENTIFIER_POINTER (name
);
224 && (q
== IDENTIFIER_POINTER (name
) || q
[-1] == '$'))
227 while (ISDIGIT (q
[l
]))
229 if (q
[l
] == '\0' || q
[l
] == '$')
231 memcpy (p
, n
, q
- n
);
232 memcpy (p
+ (q
- n
), "Dxxxx", 5);
242 memcpy (p
, n
, IDENTIFIER_LENGTH (name
) - (n
- IDENTIFIER_POINTER (name
)));
244 if (pp_translate_identifiers (pp
))
246 const char *text
= identifier_to_locale (str
);
247 pp_append_text (pp
, text
, text
+ strlen (text
));
250 pp_append_text (pp
, str
, str
+ length
);
254 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
258 dump_decl_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
260 tree name
= DECL_NAME (node
);
263 if ((flags
& TDF_ASMNAME
)
264 && HAS_DECL_ASSEMBLER_NAME_P (node
)
265 && DECL_ASSEMBLER_NAME_SET_P (node
))
266 pp_tree_identifier (pp
, DECL_ASSEMBLER_NAME_RAW (node
));
267 /* For -fcompare-debug don't dump DECL_NAMELESS names at all,
268 -g might have created more fancy names and their indexes
269 could get out of sync. Usually those should be DECL_IGNORED_P
270 too, SRA can create even non-DECL_IGNORED_P DECL_NAMELESS fancy
271 names, let's hope those never get out of sync after doing the
272 dump_fancy_name sanitization. */
273 else if ((flags
& TDF_COMPARE_DEBUG
)
274 && DECL_NAMELESS (node
)
275 && DECL_IGNORED_P (node
))
277 /* For DECL_NAMELESS names look for embedded uids in the
278 names and sanitize them for TDF_NOUID. */
279 else if ((flags
& TDF_NOUID
) && DECL_NAMELESS (node
))
280 dump_fancy_name (pp
, name
);
282 pp_tree_identifier (pp
, name
);
284 char uid_sep
= (flags
& TDF_GIMPLE
) ? '_' : '.';
285 if ((flags
& TDF_UID
) || name
== NULL_TREE
)
287 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
288 pp_printf (pp
, "L%c%d", uid_sep
, (int) LABEL_DECL_UID (node
));
289 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
291 if (flags
& TDF_NOUID
)
292 pp_string (pp
, "D#xxxx");
294 pp_printf (pp
, "D#%i", DEBUG_TEMP_UID (node
));
298 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
299 if (flags
& TDF_NOUID
)
300 pp_printf (pp
, "%c.xxxx", c
);
302 pp_printf (pp
, "%c%c%u", c
, uid_sep
, DECL_UID (node
));
305 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
307 if (flags
& TDF_NOUID
)
308 pp_printf (pp
, "ptD.xxxx");
310 pp_printf (pp
, "ptD.%u", DECL_PT_UID (node
));
314 /* Like the above, but used for pretty printing function calls. */
317 dump_function_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
319 if (CONVERT_EXPR_P (node
))
320 node
= TREE_OPERAND (node
, 0);
321 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
322 pp_string (pp
, lang_hooks
.decl_printable_name (node
, 1));
324 dump_decl_name (pp
, node
, flags
);
327 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
328 FLAGS are as in dump_generic_node. */
331 dump_function_declaration (pretty_printer
*pp
, tree node
,
332 int spc
, dump_flags_t flags
)
334 bool wrote_arg
= false;
340 /* Print the argument types. */
341 arg
= TYPE_ARG_TYPES (node
);
342 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
350 dump_generic_node (pp
, TREE_VALUE (arg
), spc
, flags
, false);
351 arg
= TREE_CHAIN (arg
);
354 /* Drop the trailing void_type_node if we had any previous argument. */
355 if (arg
== void_list_node
&& !wrote_arg
)
356 pp_string (pp
, "void");
357 /* Properly dump vararg function types. */
358 else if (!arg
&& wrote_arg
)
359 pp_string (pp
, ", ...");
360 /* Avoid printing any arg for unprototyped functions. */
365 /* Dump the domain associated with an array. */
368 dump_array_domain (pretty_printer
*pp
, tree domain
, int spc
, dump_flags_t flags
)
370 pp_left_bracket (pp
);
373 tree min
= TYPE_MIN_VALUE (domain
);
374 tree max
= TYPE_MAX_VALUE (domain
);
377 && integer_zerop (min
)
378 && tree_fits_shwi_p (max
))
379 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
383 dump_generic_node (pp
, min
, spc
, flags
, false);
386 dump_generic_node (pp
, max
, spc
, flags
, false);
390 pp_string (pp
, "<unknown>");
391 pp_right_bracket (pp
);
395 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
396 dump_generic_node. */
399 dump_omp_clause (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
403 switch (OMP_CLAUSE_CODE (clause
))
405 case OMP_CLAUSE_PRIVATE
:
408 case OMP_CLAUSE_SHARED
:
411 case OMP_CLAUSE_FIRSTPRIVATE
:
412 name
= "firstprivate";
414 case OMP_CLAUSE_LASTPRIVATE
:
415 name
= "lastprivate";
417 case OMP_CLAUSE_COPYIN
:
420 case OMP_CLAUSE_COPYPRIVATE
:
421 name
= "copyprivate";
423 case OMP_CLAUSE_UNIFORM
:
426 case OMP_CLAUSE_USE_DEVICE_PTR
:
427 name
= "use_device_ptr";
429 case OMP_CLAUSE_IS_DEVICE_PTR
:
430 name
= "is_device_ptr";
432 case OMP_CLAUSE__LOOPTEMP_
:
435 case OMP_CLAUSE_TO_DECLARE
:
438 case OMP_CLAUSE_LINK
:
442 pp_string (pp
, name
);
444 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
449 case OMP_CLAUSE_REDUCTION
:
450 pp_string (pp
, "reduction(");
451 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
454 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
457 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
463 pp_string (pp
, "if(");
464 switch (OMP_CLAUSE_IF_MODIFIER (clause
))
466 case ERROR_MARK
: break;
467 case OMP_PARALLEL
: pp_string (pp
, "parallel:"); break;
468 case OMP_TASK
: pp_string (pp
, "task:"); break;
469 case OMP_TASKLOOP
: pp_string (pp
, "taskloop:"); break;
470 case OMP_TARGET_DATA
: pp_string (pp
, "target data:"); break;
471 case OMP_TARGET
: pp_string (pp
, "target:"); break;
472 case OMP_TARGET_UPDATE
: pp_string (pp
, "target update:"); break;
473 case OMP_TARGET_ENTER_DATA
:
474 pp_string (pp
, "target enter data:"); break;
475 case OMP_TARGET_EXIT_DATA
: pp_string (pp
, "target exit data:"); break;
476 default: gcc_unreachable ();
478 dump_generic_node (pp
, OMP_CLAUSE_IF_EXPR (clause
),
483 case OMP_CLAUSE_NUM_THREADS
:
484 pp_string (pp
, "num_threads(");
485 dump_generic_node (pp
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
490 case OMP_CLAUSE_NOWAIT
:
491 pp_string (pp
, "nowait");
493 case OMP_CLAUSE_ORDERED
:
494 pp_string (pp
, "ordered");
495 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
498 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
504 case OMP_CLAUSE_DEFAULT
:
505 pp_string (pp
, "default(");
506 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
508 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
510 case OMP_CLAUSE_DEFAULT_SHARED
:
511 pp_string (pp
, "shared");
513 case OMP_CLAUSE_DEFAULT_NONE
:
514 pp_string (pp
, "none");
516 case OMP_CLAUSE_DEFAULT_PRIVATE
:
517 pp_string (pp
, "private");
519 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
520 pp_string (pp
, "firstprivate");
522 case OMP_CLAUSE_DEFAULT_PRESENT
:
523 pp_string (pp
, "present");
531 case OMP_CLAUSE_SCHEDULE
:
532 pp_string (pp
, "schedule(");
533 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
534 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
535 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
537 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
538 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
539 pp_string (pp
, "monotonic");
541 pp_string (pp
, "nonmonotonic");
542 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
547 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
548 pp_string (pp
, "simd:");
550 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
552 case OMP_CLAUSE_SCHEDULE_STATIC
:
553 pp_string (pp
, "static");
555 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
556 pp_string (pp
, "dynamic");
558 case OMP_CLAUSE_SCHEDULE_GUIDED
:
559 pp_string (pp
, "guided");
561 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
562 pp_string (pp
, "runtime");
564 case OMP_CLAUSE_SCHEDULE_AUTO
:
565 pp_string (pp
, "auto");
570 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
573 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
579 case OMP_CLAUSE_UNTIED
:
580 pp_string (pp
, "untied");
583 case OMP_CLAUSE_COLLAPSE
:
584 pp_string (pp
, "collapse(");
585 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
590 case OMP_CLAUSE_FINAL
:
591 pp_string (pp
, "final(");
592 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
597 case OMP_CLAUSE_MERGEABLE
:
598 pp_string (pp
, "mergeable");
601 case OMP_CLAUSE_LINEAR
:
602 pp_string (pp
, "linear(");
603 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
605 case OMP_CLAUSE_LINEAR_DEFAULT
:
607 case OMP_CLAUSE_LINEAR_REF
:
608 pp_string (pp
, "ref(");
610 case OMP_CLAUSE_LINEAR_VAL
:
611 pp_string (pp
, "val(");
613 case OMP_CLAUSE_LINEAR_UVAL
:
614 pp_string (pp
, "uval(");
619 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
621 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
624 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
629 case OMP_CLAUSE_ALIGNED
:
630 pp_string (pp
, "aligned(");
631 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
633 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
636 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
642 case OMP_CLAUSE_DEPEND
:
643 pp_string (pp
, "depend(");
644 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
646 case OMP_CLAUSE_DEPEND_IN
:
647 pp_string (pp
, "in");
649 case OMP_CLAUSE_DEPEND_OUT
:
650 pp_string (pp
, "out");
652 case OMP_CLAUSE_DEPEND_INOUT
:
653 pp_string (pp
, "inout");
655 case OMP_CLAUSE_DEPEND_SOURCE
:
656 pp_string (pp
, "source)");
658 case OMP_CLAUSE_DEPEND_SINK
:
659 pp_string (pp
, "sink:");
660 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
661 if (TREE_CODE (t
) == TREE_LIST
)
663 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
664 if (TREE_PURPOSE (t
) != integer_zero_node
)
666 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
670 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
684 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
690 pp_string (pp
, "map(");
691 switch (OMP_CLAUSE_MAP_KIND (clause
))
694 case GOMP_MAP_POINTER
:
695 pp_string (pp
, "alloc");
698 case GOMP_MAP_TO_PSET
:
699 pp_string (pp
, "to");
702 pp_string (pp
, "from");
704 case GOMP_MAP_TOFROM
:
705 pp_string (pp
, "tofrom");
707 case GOMP_MAP_FORCE_ALLOC
:
708 pp_string (pp
, "force_alloc");
710 case GOMP_MAP_FORCE_TO
:
711 pp_string (pp
, "force_to");
713 case GOMP_MAP_FORCE_FROM
:
714 pp_string (pp
, "force_from");
716 case GOMP_MAP_FORCE_TOFROM
:
717 pp_string (pp
, "force_tofrom");
719 case GOMP_MAP_FORCE_PRESENT
:
720 pp_string (pp
, "force_present");
722 case GOMP_MAP_DELETE
:
723 pp_string (pp
, "delete");
725 case GOMP_MAP_FORCE_DEVICEPTR
:
726 pp_string (pp
, "force_deviceptr");
728 case GOMP_MAP_ALWAYS_TO
:
729 pp_string (pp
, "always,to");
731 case GOMP_MAP_ALWAYS_FROM
:
732 pp_string (pp
, "always,from");
734 case GOMP_MAP_ALWAYS_TOFROM
:
735 pp_string (pp
, "always,tofrom");
737 case GOMP_MAP_RELEASE
:
738 pp_string (pp
, "release");
740 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
741 pp_string (pp
, "firstprivate");
743 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
744 pp_string (pp
, "firstprivate ref");
746 case GOMP_MAP_STRUCT
:
747 pp_string (pp
, "struct");
749 case GOMP_MAP_ALWAYS_POINTER
:
750 pp_string (pp
, "always_pointer");
752 case GOMP_MAP_DEVICE_RESIDENT
:
753 pp_string (pp
, "device_resident");
756 pp_string (pp
, "link");
762 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
765 if (OMP_CLAUSE_SIZE (clause
))
767 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
768 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
770 case GOMP_MAP_POINTER
:
771 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
772 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
773 case GOMP_MAP_ALWAYS_POINTER
:
774 pp_string (pp
, " [pointer assign, bias: ");
776 case GOMP_MAP_TO_PSET
:
777 pp_string (pp
, " [pointer set, len: ");
780 pp_string (pp
, " [len: ");
783 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
785 pp_right_bracket (pp
);
790 case OMP_CLAUSE_FROM
:
791 pp_string (pp
, "from(");
792 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
794 goto print_clause_size
;
797 pp_string (pp
, "to(");
798 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
800 goto print_clause_size
;
802 case OMP_CLAUSE__CACHE_
:
804 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
806 goto print_clause_size
;
808 case OMP_CLAUSE_NUM_TEAMS
:
809 pp_string (pp
, "num_teams(");
810 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
815 case OMP_CLAUSE_THREAD_LIMIT
:
816 pp_string (pp
, "thread_limit(");
817 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
822 case OMP_CLAUSE_DEVICE
:
823 pp_string (pp
, "device(");
824 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
829 case OMP_CLAUSE_DIST_SCHEDULE
:
830 pp_string (pp
, "dist_schedule(static");
831 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
834 dump_generic_node (pp
,
835 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
841 case OMP_CLAUSE_PROC_BIND
:
842 pp_string (pp
, "proc_bind(");
843 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
845 case OMP_CLAUSE_PROC_BIND_MASTER
:
846 pp_string (pp
, "master");
848 case OMP_CLAUSE_PROC_BIND_CLOSE
:
849 pp_string (pp
, "close");
851 case OMP_CLAUSE_PROC_BIND_SPREAD
:
852 pp_string (pp
, "spread");
860 case OMP_CLAUSE_SAFELEN
:
861 pp_string (pp
, "safelen(");
862 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
867 case OMP_CLAUSE_SIMDLEN
:
868 pp_string (pp
, "simdlen(");
869 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
874 case OMP_CLAUSE_PRIORITY
:
875 pp_string (pp
, "priority(");
876 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
881 case OMP_CLAUSE_GRAINSIZE
:
882 pp_string (pp
, "grainsize(");
883 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
888 case OMP_CLAUSE_NUM_TASKS
:
889 pp_string (pp
, "num_tasks(");
890 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
895 case OMP_CLAUSE_HINT
:
896 pp_string (pp
, "hint(");
897 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
902 case OMP_CLAUSE_DEFAULTMAP
:
903 pp_string (pp
, "defaultmap(tofrom:scalar)");
906 case OMP_CLAUSE__SIMDUID_
:
907 pp_string (pp
, "_simduid_(");
908 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
913 case OMP_CLAUSE__SIMT_
:
914 pp_string (pp
, "_simt_");
917 case OMP_CLAUSE_GANG
:
918 pp_string (pp
, "gang");
919 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
921 pp_string (pp
, "(num: ");
922 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
925 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
927 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
931 pp_string (pp
, "static:");
932 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
933 == integer_minus_one_node
)
934 pp_character (pp
, '*');
936 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
939 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
940 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
944 case OMP_CLAUSE_ASYNC
:
945 pp_string (pp
, "async");
946 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
948 pp_character(pp
, '(');
949 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
951 pp_character(pp
, ')');
955 case OMP_CLAUSE_AUTO
:
957 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
960 case OMP_CLAUSE_WAIT
:
961 pp_string (pp
, "wait(");
962 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
964 pp_character(pp
, ')');
967 case OMP_CLAUSE_WORKER
:
968 pp_string (pp
, "worker");
969 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
972 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
978 case OMP_CLAUSE_VECTOR
:
979 pp_string (pp
, "vector");
980 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
983 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
989 case OMP_CLAUSE_NUM_GANGS
:
990 pp_string (pp
, "num_gangs(");
991 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
993 pp_character (pp
, ')');
996 case OMP_CLAUSE_NUM_WORKERS
:
997 pp_string (pp
, "num_workers(");
998 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
1000 pp_character (pp
, ')');
1003 case OMP_CLAUSE_VECTOR_LENGTH
:
1004 pp_string (pp
, "vector_length(");
1005 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
1007 pp_character (pp
, ')');
1010 case OMP_CLAUSE_INBRANCH
:
1011 pp_string (pp
, "inbranch");
1013 case OMP_CLAUSE_NOTINBRANCH
:
1014 pp_string (pp
, "notinbranch");
1016 case OMP_CLAUSE_FOR
:
1017 pp_string (pp
, "for");
1019 case OMP_CLAUSE_PARALLEL
:
1020 pp_string (pp
, "parallel");
1022 case OMP_CLAUSE_SECTIONS
:
1023 pp_string (pp
, "sections");
1025 case OMP_CLAUSE_TASKGROUP
:
1026 pp_string (pp
, "taskgroup");
1028 case OMP_CLAUSE_NOGROUP
:
1029 pp_string (pp
, "nogroup");
1031 case OMP_CLAUSE_THREADS
:
1032 pp_string (pp
, "threads");
1034 case OMP_CLAUSE_SIMD
:
1035 pp_string (pp
, "simd");
1037 case OMP_CLAUSE_INDEPENDENT
:
1038 pp_string (pp
, "independent");
1040 case OMP_CLAUSE_TILE
:
1041 pp_string (pp
, "tile(");
1042 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1044 pp_right_paren (pp
);
1047 case OMP_CLAUSE__GRIDDIM_
:
1048 pp_string (pp
, "_griddim_(");
1049 pp_unsigned_wide_integer (pp
, OMP_CLAUSE__GRIDDIM__DIMENSION (clause
));
1051 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__SIZE (clause
), spc
, flags
,
1054 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__GROUP (clause
), spc
, flags
,
1056 pp_right_paren (pp
);
1058 case OMP_CLAUSE_IF_PRESENT
:
1059 pp_string (pp
, "if_present");
1061 case OMP_CLAUSE_FINALIZE
:
1062 pp_string (pp
, "finalize");
1066 /* Should never happen. */
1067 dump_generic_node (pp
, clause
, spc
, flags
, false);
1073 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1074 dump_generic_node. */
1077 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
1085 dump_omp_clause (pp
, clause
, spc
, flags
);
1086 clause
= OMP_CLAUSE_CHAIN (clause
);
1094 /* Dump location LOC to PP. */
1097 dump_location (pretty_printer
*pp
, location_t loc
)
1099 expanded_location xloc
= expand_location (loc
);
1101 pp_left_bracket (pp
);
1104 pp_string (pp
, xloc
.file
);
1105 pp_string (pp
, ":");
1107 pp_decimal_int (pp
, xloc
.line
);
1109 pp_decimal_int (pp
, xloc
.column
);
1110 pp_string (pp
, "] ");
1114 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1115 dump_generic_node. */
1118 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, dump_flags_t flags
)
1122 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1124 if (flags
& TDF_ADDRESS
)
1125 pp_printf (pp
, "[%p] ", (void *) block
);
1127 if (BLOCK_ABSTRACT (block
))
1128 pp_string (pp
, "[abstract] ");
1130 if (TREE_ASM_WRITTEN (block
))
1131 pp_string (pp
, "[written] ");
1133 if (flags
& TDF_SLIM
)
1136 if (BLOCK_SOURCE_LOCATION (block
))
1137 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1139 newline_and_indent (pp
, spc
+ 2);
1141 if (BLOCK_SUPERCONTEXT (block
))
1143 pp_string (pp
, "SUPERCONTEXT: ");
1144 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1145 flags
| TDF_SLIM
, false);
1146 newline_and_indent (pp
, spc
+ 2);
1149 if (BLOCK_SUBBLOCKS (block
))
1151 pp_string (pp
, "SUBBLOCKS: ");
1152 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1154 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1157 newline_and_indent (pp
, spc
+ 2);
1160 if (BLOCK_CHAIN (block
))
1162 pp_string (pp
, "SIBLINGS: ");
1163 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1165 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1168 newline_and_indent (pp
, spc
+ 2);
1171 if (BLOCK_VARS (block
))
1173 pp_string (pp
, "VARS: ");
1174 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1176 dump_generic_node (pp
, t
, 0, flags
, false);
1179 newline_and_indent (pp
, spc
+ 2);
1182 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1185 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1187 pp_string (pp
, "NONLOCALIZED_VARS: ");
1188 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1190 dump_generic_node (pp
, t
, 0, flags
, false);
1193 newline_and_indent (pp
, spc
+ 2);
1196 if (BLOCK_ABSTRACT_ORIGIN (block
))
1198 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1199 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1200 flags
| TDF_SLIM
, false);
1201 newline_and_indent (pp
, spc
+ 2);
1204 if (BLOCK_FRAGMENT_ORIGIN (block
))
1206 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1207 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1208 flags
| TDF_SLIM
, false);
1209 newline_and_indent (pp
, spc
+ 2);
1212 if (BLOCK_FRAGMENT_CHAIN (block
))
1214 pp_string (pp
, "FRAGMENT_CHAIN: ");
1215 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1217 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1220 newline_and_indent (pp
, spc
+ 2);
1225 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1226 indent. FLAGS specifies details to show in the dump (see TDF_* in
1227 dumpfile.h). If IS_STMT is true, the object printed is considered
1228 to be a statement and it is terminated by ';' if appropriate. */
1231 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
,
1238 enum tree_code code
;
1240 if (node
== NULL_TREE
)
1243 is_expr
= EXPR_P (node
);
1245 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1246 pp_printf (pp
, "<&%p> ", (void *)node
);
1248 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1249 dump_location (pp
, EXPR_LOCATION (node
));
1251 code
= TREE_CODE (node
);
1255 pp_string (pp
, "<<< error >>>");
1258 case IDENTIFIER_NODE
:
1259 pp_tree_identifier (pp
, node
);
1263 while (node
&& node
!= error_mark_node
)
1265 if (TREE_PURPOSE (node
))
1267 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1270 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1271 node
= TREE_CHAIN (node
);
1272 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1281 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1287 if (TREE_VEC_LENGTH (node
) > 0)
1289 size_t len
= TREE_VEC_LENGTH (node
);
1290 for (i
= 0; i
< len
- 1; i
++)
1292 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1297 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1306 case FIXED_POINT_TYPE
:
1312 unsigned int quals
= TYPE_QUALS (node
);
1313 enum tree_code_class tclass
;
1315 if (quals
& TYPE_QUAL_ATOMIC
)
1316 pp_string (pp
, "atomic ");
1317 if (quals
& TYPE_QUAL_CONST
)
1318 pp_string (pp
, "const ");
1319 else if (quals
& TYPE_QUAL_VOLATILE
)
1320 pp_string (pp
, "volatile ");
1321 else if (quals
& TYPE_QUAL_RESTRICT
)
1322 pp_string (pp
, "restrict ");
1324 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1326 pp_string (pp
, "<address-space-");
1327 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1328 pp_string (pp
, "> ");
1331 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1333 if (tclass
== tcc_declaration
)
1335 if (DECL_NAME (node
))
1336 dump_decl_name (pp
, node
, flags
);
1338 pp_string (pp
, "<unnamed type decl>");
1340 else if (tclass
== tcc_type
)
1342 if (TYPE_NAME (node
))
1344 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1345 pp_tree_identifier (pp
, TYPE_NAME (node
));
1346 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1347 && DECL_NAME (TYPE_NAME (node
)))
1348 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1350 pp_string (pp
, "<unnamed type>");
1352 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1354 pp_string (pp
, "vector");
1356 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1357 pp_string (pp
, ") ");
1358 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1360 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1362 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1363 pp_string (pp
, (TYPE_UNSIGNED (node
)
1366 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1367 pp_string (pp
, (TYPE_UNSIGNED (node
)
1370 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1371 pp_string (pp
, (TYPE_UNSIGNED (node
)
1374 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1375 pp_string (pp
, (TYPE_UNSIGNED (node
)
1378 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1379 pp_string (pp
, (TYPE_UNSIGNED (node
)
1380 ? "unsigned long long"
1381 : "signed long long"));
1382 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1383 && pow2p_hwi (TYPE_PRECISION (node
)))
1385 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1386 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1387 pp_string (pp
, "_t");
1391 pp_string (pp
, (TYPE_UNSIGNED (node
)
1392 ? "<unnamed-unsigned:"
1393 : "<unnamed-signed:"));
1394 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1398 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1400 pp_string (pp
, "__complex__ ");
1401 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1403 else if (TREE_CODE (node
) == REAL_TYPE
)
1405 pp_string (pp
, "<float:");
1406 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1409 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1411 pp_string (pp
, "<fixed-point-");
1412 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1413 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1416 else if (TREE_CODE (node
) == VOID_TYPE
)
1417 pp_string (pp
, "void");
1419 pp_string (pp
, "<unnamed type>");
1425 case REFERENCE_TYPE
:
1426 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1428 if (TREE_TYPE (node
) == NULL
)
1430 pp_string (pp
, str
);
1431 pp_string (pp
, "<null type>");
1433 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1435 tree fnode
= TREE_TYPE (node
);
1437 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1440 pp_string (pp
, str
);
1441 if (TYPE_IDENTIFIER (node
))
1442 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1443 else if (flags
& TDF_NOUID
)
1444 pp_printf (pp
, "<Txxxx>");
1446 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1448 pp_right_paren (pp
);
1449 dump_function_declaration (pp
, fnode
, spc
, flags
);
1453 unsigned int quals
= TYPE_QUALS (node
);
1455 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1457 pp_string (pp
, str
);
1459 if (quals
& TYPE_QUAL_CONST
)
1460 pp_string (pp
, " const");
1461 if (quals
& TYPE_QUAL_VOLATILE
)
1462 pp_string (pp
, " volatile");
1463 if (quals
& TYPE_QUAL_RESTRICT
)
1464 pp_string (pp
, " restrict");
1466 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1468 pp_string (pp
, " <address-space-");
1469 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1473 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1474 pp_string (pp
, " {ref-all}");
1484 if (flags
& TDF_GIMPLE
)
1486 pp_string (pp
, "__MEM <");
1487 dump_generic_node (pp
, TREE_TYPE (node
),
1488 spc
, flags
| TDF_SLIM
, false);
1489 if (TYPE_ALIGN (TREE_TYPE (node
))
1490 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
1492 pp_string (pp
, ", ");
1493 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
1496 pp_string (pp
, " (");
1497 if (TREE_TYPE (TREE_OPERAND (node
, 0))
1498 != TREE_TYPE (TREE_OPERAND (node
, 1)))
1501 dump_generic_node (pp
, TREE_TYPE (TREE_OPERAND (node
, 1)),
1502 spc
, flags
| TDF_SLIM
, false);
1503 pp_right_paren (pp
);
1505 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1506 spc
, flags
| TDF_SLIM
, false);
1507 if (! integer_zerop (TREE_OPERAND (node
, 1)))
1509 pp_string (pp
, " + ");
1510 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1511 spc
, flags
| TDF_SLIM
, false);
1513 pp_right_paren (pp
);
1515 else if (integer_zerop (TREE_OPERAND (node
, 1))
1516 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1517 infer them and MEM_ATTR caching will share MEM_REFs
1518 with differently-typed op0s. */
1519 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1520 /* Released SSA_NAMES have no TREE_TYPE. */
1521 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1522 /* Same pointer types, but ignoring POINTER_TYPE vs.
1524 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1525 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1526 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1527 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1528 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1529 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1530 /* Same value types ignoring qualifiers. */
1531 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1532 == TYPE_MAIN_VARIANT
1533 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1534 && (!(flags
& TDF_ALIAS
)
1535 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1537 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1540 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1544 dump_generic_node (pp
,
1545 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1552 pp_string (pp
, "MEM[");
1554 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1555 dump_generic_node (pp
, ptype
,
1556 spc
, flags
| TDF_SLIM
, false);
1557 pp_right_paren (pp
);
1558 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1560 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1562 pp_string (pp
, " + ");
1563 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1566 if ((flags
& TDF_ALIAS
)
1567 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1569 pp_string (pp
, " clique ");
1570 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1571 pp_string (pp
, " base ");
1572 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1574 pp_right_bracket (pp
);
1579 case TARGET_MEM_REF
:
1581 const char *sep
= "";
1584 pp_string (pp
, "MEM[");
1586 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1588 pp_string (pp
, sep
);
1590 pp_string (pp
, "symbol: ");
1591 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1596 pp_string (pp
, sep
);
1598 pp_string (pp
, "base: ");
1599 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1601 tmp
= TMR_INDEX2 (node
);
1604 pp_string (pp
, sep
);
1606 pp_string (pp
, "base: ");
1607 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1609 tmp
= TMR_INDEX (node
);
1612 pp_string (pp
, sep
);
1614 pp_string (pp
, "index: ");
1615 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1617 tmp
= TMR_STEP (node
);
1620 pp_string (pp
, sep
);
1622 pp_string (pp
, "step: ");
1623 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1625 tmp
= TMR_OFFSET (node
);
1628 pp_string (pp
, sep
);
1630 pp_string (pp
, "offset: ");
1631 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1633 pp_right_bracket (pp
);
1641 /* Print the innermost component type. */
1642 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1643 tmp
= TREE_TYPE (tmp
))
1645 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1647 /* Print the dimensions. */
1648 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1649 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1655 case QUAL_UNION_TYPE
:
1657 unsigned int quals
= TYPE_QUALS (node
);
1659 if (quals
& TYPE_QUAL_ATOMIC
)
1660 pp_string (pp
, "atomic ");
1661 if (quals
& TYPE_QUAL_CONST
)
1662 pp_string (pp
, "const ");
1663 if (quals
& TYPE_QUAL_VOLATILE
)
1664 pp_string (pp
, "volatile ");
1666 /* Print the name of the structure. */
1667 if (TREE_CODE (node
) == RECORD_TYPE
)
1668 pp_string (pp
, "struct ");
1669 else if (TREE_CODE (node
) == UNION_TYPE
)
1670 pp_string (pp
, "union ");
1672 if (TYPE_NAME (node
))
1673 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1674 else if (!(flags
& TDF_SLIM
))
1675 /* FIXME: If we eliminate the 'else' above and attempt
1676 to show the fields for named types, we may get stuck
1677 following a cycle of pointers to structs. The alleged
1678 self-reference check in print_struct_decl will not detect
1679 cycles involving more than one pointer or struct type. */
1680 print_struct_decl (pp
, node
, spc
, flags
);
1689 if (flags
& TDF_GIMPLE
1690 && (POINTER_TYPE_P (TREE_TYPE (node
))
1691 || (TYPE_PRECISION (TREE_TYPE (node
))
1692 < TYPE_PRECISION (integer_type_node
))
1693 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1695 pp_string (pp
, "_Literal (");
1696 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1697 pp_string (pp
, ") ");
1699 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
1700 && ! (flags
& TDF_GIMPLE
))
1702 /* In the case of a pointer, one may want to divide by the
1703 size of the pointed-to type. Unfortunately, this not
1704 straightforward. The C front-end maps expressions
1709 in such a way that the two INTEGER_CST nodes for "5" have
1710 different values but identical types. In the latter
1711 case, the 5 is multiplied by sizeof (int) in c-common.c
1712 (pointer_int_sum) to convert it to a byte address, and
1713 yet the type of the node is left unchanged. Argh. What
1714 is consistent though is that the number value corresponds
1715 to bytes (UNITS) offset.
1717 NB: Neither of the following divisors can be trivially
1718 used to recover the original literal:
1720 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1721 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1722 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1723 pp_string (pp
, "B"); /* pseudo-unit */
1725 else if (tree_fits_shwi_p (node
))
1726 pp_wide_integer (pp
, tree_to_shwi (node
));
1727 else if (tree_fits_uhwi_p (node
))
1728 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1731 wide_int val
= wi::to_wide (node
);
1733 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1738 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
1739 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
1741 if ((flags
& TDF_GIMPLE
)
1742 && ! (POINTER_TYPE_P (TREE_TYPE (node
))
1743 || (TYPE_PRECISION (TREE_TYPE (node
))
1744 < TYPE_PRECISION (integer_type_node
))
1745 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1747 if (TYPE_UNSIGNED (TREE_TYPE (node
)))
1748 pp_character (pp
, 'u');
1749 if (TYPE_PRECISION (TREE_TYPE (node
))
1750 == TYPE_PRECISION (unsigned_type_node
))
1752 else if (TYPE_PRECISION (TREE_TYPE (node
))
1753 == TYPE_PRECISION (long_unsigned_type_node
))
1754 pp_character (pp
, 'l');
1755 else if (TYPE_PRECISION (TREE_TYPE (node
))
1756 == TYPE_PRECISION (long_long_unsigned_type_node
))
1757 pp_string (pp
, "ll");
1759 if (TREE_OVERFLOW (node
))
1760 pp_string (pp
, "(OVF)");
1764 pp_string (pp
, "POLY_INT_CST [");
1765 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, 0), spc
, flags
, false);
1766 for (unsigned int i
= 1; i
< NUM_POLY_INT_COEFFS
; ++i
)
1768 pp_string (pp
, ", ");
1769 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, i
),
1772 pp_string (pp
, "]");
1776 /* Code copied from print_node. */
1779 if (TREE_OVERFLOW (node
))
1780 pp_string (pp
, " overflow");
1782 d
= TREE_REAL_CST (node
);
1783 if (REAL_VALUE_ISINF (d
))
1784 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1785 else if (REAL_VALUE_ISNAN (d
))
1786 pp_string (pp
, " Nan");
1790 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1791 pp_string (pp
, string
);
1799 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1800 pp_string (pp
, string
);
1805 pp_string (pp
, "__complex__ (");
1806 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
1807 pp_string (pp
, ", ");
1808 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
1809 pp_right_paren (pp
);
1814 pp_string (pp
, "\"");
1815 if (unsigned nbytes
= TREE_STRING_LENGTH (node
))
1816 pretty_print_string (pp
, TREE_STRING_POINTER (node
), nbytes
);
1817 pp_string (pp
, "\"");
1824 pp_string (pp
, "{ ");
1825 unsigned HOST_WIDE_INT nunits
;
1826 if (!VECTOR_CST_NELTS (node
).is_constant (&nunits
))
1827 nunits
= vector_cst_encoded_nelts (node
);
1828 for (i
= 0; i
< nunits
; ++i
)
1831 pp_string (pp
, ", ");
1832 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
1835 if (!VECTOR_CST_NELTS (node
).is_constant ())
1836 pp_string (pp
, ", ...");
1837 pp_string (pp
, " }");
1843 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1845 if (TREE_CODE (node
) == METHOD_TYPE
)
1847 if (TYPE_METHOD_BASETYPE (node
))
1848 dump_generic_node (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1851 pp_string (pp
, "<null method basetype>");
1852 pp_colon_colon (pp
);
1854 if (TYPE_IDENTIFIER (node
))
1855 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1856 else if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1857 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1858 else if (flags
& TDF_NOUID
)
1859 pp_printf (pp
, "<Txxxx>");
1861 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1862 dump_function_declaration (pp
, node
, spc
, flags
);
1867 dump_decl_name (pp
, node
, flags
);
1871 if (DECL_NAME (node
))
1872 dump_decl_name (pp
, node
, flags
);
1873 else if (LABEL_DECL_UID (node
) != -1)
1875 if (flags
& TDF_GIMPLE
)
1876 pp_printf (pp
, "L%d", (int) LABEL_DECL_UID (node
));
1878 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
1882 if (flags
& TDF_NOUID
)
1883 pp_string (pp
, "<D.xxxx>");
1886 if (flags
& TDF_GIMPLE
)
1887 pp_printf (pp
, "<D%u>", DECL_UID (node
));
1889 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
1895 if (DECL_IS_BUILTIN (node
))
1897 /* Don't print the declaration of built-in types. */
1900 if (DECL_NAME (node
))
1901 dump_decl_name (pp
, node
, flags
);
1902 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1904 pp_string (pp
, (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1905 ? "union" : "struct "));
1906 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1909 pp_string (pp
, "<anon>");
1915 case DEBUG_EXPR_DECL
:
1916 case NAMESPACE_DECL
:
1918 dump_decl_name (pp
, node
, flags
);
1922 pp_string (pp
, "<retval>");
1926 op0
= TREE_OPERAND (node
, 0);
1929 && (TREE_CODE (op0
) == INDIRECT_REF
1930 || (TREE_CODE (op0
) == MEM_REF
1931 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1932 && integer_zerop (TREE_OPERAND (op0
, 1))
1933 /* Dump the types of INTEGER_CSTs explicitly, for we
1934 can't infer them and MEM_ATTR caching will share
1935 MEM_REFs with differently-typed op0s. */
1936 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1937 /* Released SSA_NAMES have no TREE_TYPE. */
1938 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1939 /* Same pointer types, but ignoring POINTER_TYPE vs.
1941 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1942 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1943 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1944 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1945 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1946 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1947 /* Same value types ignoring qualifiers. */
1948 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1949 == TYPE_MAIN_VARIANT
1950 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
1951 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
1953 op0
= TREE_OPERAND (op0
, 0);
1956 if (op_prio (op0
) < op_prio (node
))
1958 dump_generic_node (pp
, op0
, spc
, flags
, false);
1959 if (op_prio (op0
) < op_prio (node
))
1960 pp_right_paren (pp
);
1961 pp_string (pp
, str
);
1962 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1963 op0
= component_ref_field_offset (node
);
1964 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1966 pp_string (pp
, "{off: ");
1967 dump_generic_node (pp
, op0
, spc
, flags
, false);
1968 pp_right_brace (pp
);
1973 pp_string (pp
, "BIT_FIELD_REF <");
1974 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1975 pp_string (pp
, ", ");
1976 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1977 pp_string (pp
, ", ");
1978 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1982 case BIT_INSERT_EXPR
:
1983 pp_string (pp
, "BIT_INSERT_EXPR <");
1984 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1985 pp_string (pp
, ", ");
1986 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1987 pp_string (pp
, ", ");
1988 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1989 pp_string (pp
, " (");
1990 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
1992 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
1994 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
1996 pp_string (pp
, " bits)>");
2000 case ARRAY_RANGE_REF
:
2001 op0
= TREE_OPERAND (node
, 0);
2002 if (op_prio (op0
) < op_prio (node
))
2004 dump_generic_node (pp
, op0
, spc
, flags
, false);
2005 if (op_prio (op0
) < op_prio (node
))
2006 pp_right_paren (pp
);
2007 pp_left_bracket (pp
);
2008 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2009 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
2010 pp_string (pp
, " ...");
2011 pp_right_bracket (pp
);
2013 op0
= array_ref_low_bound (node
);
2014 op1
= array_ref_element_size (node
);
2016 if (!integer_zerop (op0
)
2017 || TREE_OPERAND (node
, 2)
2018 || TREE_OPERAND (node
, 3))
2020 pp_string (pp
, "{lb: ");
2021 dump_generic_node (pp
, op0
, spc
, flags
, false);
2022 pp_string (pp
, " sz: ");
2023 dump_generic_node (pp
, op1
, spc
, flags
, false);
2024 pp_right_brace (pp
);
2030 unsigned HOST_WIDE_INT ix
;
2032 bool is_struct_init
= false;
2033 bool is_array_init
= false;
2036 if (TREE_CLOBBER_P (node
))
2037 pp_string (pp
, "CLOBBER");
2038 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
2039 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
2040 is_struct_init
= true;
2041 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
2042 && TYPE_DOMAIN (TREE_TYPE (node
))
2043 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
2044 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
2047 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
2048 is_array_init
= true;
2049 curidx
= wi::to_widest (minv
);
2051 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
2058 dump_generic_node (pp
, field
, spc
, flags
, false);
2061 else if (is_array_init
2062 && (TREE_CODE (field
) != INTEGER_CST
2063 || curidx
!= wi::to_widest (field
)))
2065 pp_left_bracket (pp
);
2066 if (TREE_CODE (field
) == RANGE_EXPR
)
2068 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
2070 pp_string (pp
, " ... ");
2071 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
2073 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
2074 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
2077 dump_generic_node (pp
, field
, spc
, flags
, false);
2078 if (TREE_CODE (field
) == INTEGER_CST
)
2079 curidx
= wi::to_widest (field
);
2080 pp_string (pp
, "]=");
2085 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
2086 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
2087 val
= TREE_OPERAND (val
, 0);
2088 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
2089 dump_decl_name (pp
, val
, flags
);
2091 dump_generic_node (pp
, val
, spc
, flags
, false);
2092 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2098 pp_right_brace (pp
);
2105 if (flags
& TDF_SLIM
)
2107 pp_string (pp
, "<COMPOUND_EXPR>");
2111 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2112 spc
, flags
, !(flags
& TDF_SLIM
));
2113 if (flags
& TDF_SLIM
)
2114 newline_and_indent (pp
, spc
);
2121 for (tp
= &TREE_OPERAND (node
, 1);
2122 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2123 tp
= &TREE_OPERAND (*tp
, 1))
2125 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2126 spc
, flags
, !(flags
& TDF_SLIM
));
2127 if (flags
& TDF_SLIM
)
2128 newline_and_indent (pp
, spc
);
2136 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2140 case STATEMENT_LIST
:
2142 tree_stmt_iterator si
;
2145 if (flags
& TDF_SLIM
)
2147 pp_string (pp
, "<STATEMENT_LIST>");
2151 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2154 newline_and_indent (pp
, spc
);
2157 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2164 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2169 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2174 pp_string (pp
, "TARGET_EXPR <");
2175 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2178 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2183 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2188 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2190 pp_string (pp
, "if (");
2191 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2192 pp_right_paren (pp
);
2193 /* The lowered cond_exprs should always be printed in full. */
2194 if (COND_EXPR_THEN (node
)
2195 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2196 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2197 && COND_EXPR_ELSE (node
)
2198 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2199 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2202 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2204 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2206 pp_string (pp
, " else ");
2207 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2211 else if (!(flags
& TDF_SLIM
))
2213 /* Output COND_EXPR_THEN. */
2214 if (COND_EXPR_THEN (node
))
2216 newline_and_indent (pp
, spc
+2);
2218 newline_and_indent (pp
, spc
+4);
2219 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2221 newline_and_indent (pp
, spc
+2);
2222 pp_right_brace (pp
);
2225 /* Output COND_EXPR_ELSE. */
2226 if (COND_EXPR_ELSE (node
)
2227 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2229 newline_and_indent (pp
, spc
);
2230 pp_string (pp
, "else");
2231 newline_and_indent (pp
, spc
+2);
2233 newline_and_indent (pp
, spc
+4);
2234 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2236 newline_and_indent (pp
, spc
+2);
2237 pp_right_brace (pp
);
2244 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2248 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2252 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2258 if (!(flags
& TDF_SLIM
))
2260 if (BIND_EXPR_VARS (node
))
2264 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2266 print_declaration (pp
, op0
, spc
+2, flags
);
2271 newline_and_indent (pp
, spc
+2);
2272 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2273 newline_and_indent (pp
, spc
);
2274 pp_right_brace (pp
);
2280 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2281 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2285 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2288 /* Print parameters. */
2293 call_expr_arg_iterator iter
;
2294 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2296 dump_generic_node (pp
, arg
, spc
, flags
, false);
2297 if (more_call_expr_args_p (&iter
))
2304 if (CALL_EXPR_VA_ARG_PACK (node
))
2306 if (call_expr_nargs (node
) > 0)
2311 pp_string (pp
, "__builtin_va_arg_pack ()");
2313 pp_right_paren (pp
);
2315 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2318 pp_string (pp
, " [static-chain: ");
2319 dump_generic_node (pp
, op1
, spc
, flags
, false);
2320 pp_right_bracket (pp
);
2323 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2324 pp_string (pp
, " [return slot optimization]");
2325 if (CALL_EXPR_TAILCALL (node
))
2326 pp_string (pp
, " [tail call]");
2329 case WITH_CLEANUP_EXPR
:
2333 case CLEANUP_POINT_EXPR
:
2334 pp_string (pp
, "<<cleanup_point ");
2335 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2336 pp_string (pp
, ">>");
2339 case PLACEHOLDER_EXPR
:
2340 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2341 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2345 /* Binary arithmetic and logic expressions. */
2346 case WIDEN_SUM_EXPR
:
2347 case WIDEN_MULT_EXPR
:
2349 case MULT_HIGHPART_EXPR
:
2351 case POINTER_PLUS_EXPR
:
2352 case POINTER_DIFF_EXPR
:
2354 case TRUNC_DIV_EXPR
:
2356 case FLOOR_DIV_EXPR
:
2357 case ROUND_DIV_EXPR
:
2358 case TRUNC_MOD_EXPR
:
2360 case FLOOR_MOD_EXPR
:
2361 case ROUND_MOD_EXPR
:
2363 case EXACT_DIV_EXPR
:
2368 case WIDEN_LSHIFT_EXPR
:
2372 case TRUTH_ANDIF_EXPR
:
2373 case TRUTH_ORIF_EXPR
:
2374 case TRUTH_AND_EXPR
:
2376 case TRUTH_XOR_EXPR
:
2390 case UNORDERED_EXPR
:
2392 const char *op
= op_symbol (node
);
2393 op0
= TREE_OPERAND (node
, 0);
2394 op1
= TREE_OPERAND (node
, 1);
2396 /* When the operands are expressions with less priority,
2397 keep semantics of the tree representation. */
2398 if (op_prio (op0
) <= op_prio (node
))
2401 dump_generic_node (pp
, op0
, spc
, flags
, false);
2402 pp_right_paren (pp
);
2405 dump_generic_node (pp
, op0
, spc
, flags
, false);
2411 /* When the operands are expressions with less priority,
2412 keep semantics of the tree representation. */
2413 if (op_prio (op1
) <= op_prio (node
))
2416 dump_generic_node (pp
, op1
, spc
, flags
, false);
2417 pp_right_paren (pp
);
2420 dump_generic_node (pp
, op1
, spc
, flags
, false);
2424 /* Unary arithmetic and logic expressions. */
2427 case TRUTH_NOT_EXPR
:
2429 case PREDECREMENT_EXPR
:
2430 case PREINCREMENT_EXPR
:
2432 if (TREE_CODE (node
) == ADDR_EXPR
2433 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2434 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2435 ; /* Do not output '&' for strings and function pointers. */
2437 pp_string (pp
, op_symbol (node
));
2439 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2442 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2443 pp_right_paren (pp
);
2446 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2449 case POSTDECREMENT_EXPR
:
2450 case POSTINCREMENT_EXPR
:
2451 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2454 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2455 pp_right_paren (pp
);
2458 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2459 pp_string (pp
, op_symbol (node
));
2463 pp_string (pp
, "MIN_EXPR <");
2464 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2465 pp_string (pp
, ", ");
2466 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2471 pp_string (pp
, "MAX_EXPR <");
2472 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2473 pp_string (pp
, ", ");
2474 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2479 pp_string (pp
, "ABS_EXPR <");
2480 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2485 pp_string (pp
, "ABSU_EXPR <");
2486 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2494 case ADDR_SPACE_CONVERT_EXPR
:
2495 case FIXED_CONVERT_EXPR
:
2496 case FIX_TRUNC_EXPR
:
2499 type
= TREE_TYPE (node
);
2500 op0
= TREE_OPERAND (node
, 0);
2501 if (type
!= TREE_TYPE (op0
))
2504 dump_generic_node (pp
, type
, spc
, flags
, false);
2505 pp_string (pp
, ") ");
2507 if (op_prio (op0
) < op_prio (node
))
2509 dump_generic_node (pp
, op0
, spc
, flags
, false);
2510 if (op_prio (op0
) < op_prio (node
))
2511 pp_right_paren (pp
);
2514 case VIEW_CONVERT_EXPR
:
2515 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2516 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2517 pp_string (pp
, ">(");
2518 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2519 pp_right_paren (pp
);
2523 pp_string (pp
, "((");
2524 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2525 pp_string (pp
, "))");
2528 case NON_LVALUE_EXPR
:
2529 pp_string (pp
, "NON_LVALUE_EXPR <");
2530 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2535 pp_string (pp
, "SAVE_EXPR <");
2536 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2541 pp_string (pp
, "COMPLEX_EXPR <");
2542 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2543 pp_string (pp
, ", ");
2544 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2549 pp_string (pp
, "CONJ_EXPR <");
2550 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2555 if (flags
& TDF_GIMPLE
)
2557 pp_string (pp
, "__real ");
2558 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2562 pp_string (pp
, "REALPART_EXPR <");
2563 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2569 if (flags
& TDF_GIMPLE
)
2571 pp_string (pp
, "__imag ");
2572 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2576 pp_string (pp
, "IMAGPART_EXPR <");
2577 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2583 pp_string (pp
, "VA_ARG_EXPR <");
2584 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2588 case TRY_FINALLY_EXPR
:
2589 case TRY_CATCH_EXPR
:
2590 pp_string (pp
, "try");
2591 newline_and_indent (pp
, spc
+2);
2593 newline_and_indent (pp
, spc
+4);
2594 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2595 newline_and_indent (pp
, spc
+2);
2596 pp_right_brace (pp
);
2597 newline_and_indent (pp
, spc
);
2599 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2600 newline_and_indent (pp
, spc
+2);
2602 newline_and_indent (pp
, spc
+4);
2603 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2604 newline_and_indent (pp
, spc
+2);
2605 pp_right_brace (pp
);
2610 pp_string (pp
, "catch (");
2611 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2612 pp_right_paren (pp
);
2613 newline_and_indent (pp
, spc
+2);
2615 newline_and_indent (pp
, spc
+4);
2616 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2617 newline_and_indent (pp
, spc
+2);
2618 pp_right_brace (pp
);
2622 case EH_FILTER_EXPR
:
2623 pp_string (pp
, "<<<eh_filter (");
2624 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2625 pp_string (pp
, ")>>>");
2626 newline_and_indent (pp
, spc
+2);
2628 newline_and_indent (pp
, spc
+4);
2629 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2630 newline_and_indent (pp
, spc
+2);
2631 pp_right_brace (pp
);
2636 op0
= TREE_OPERAND (node
, 0);
2637 /* If this is for break or continue, don't bother printing it. */
2638 if (DECL_NAME (op0
))
2640 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2641 if (strcmp (name
, "break") == 0
2642 || strcmp (name
, "continue") == 0)
2645 dump_generic_node (pp
, op0
, spc
, flags
, false);
2647 if (DECL_NONLOCAL (op0
))
2648 pp_string (pp
, " [non-local]");
2652 pp_string (pp
, "while (1)");
2653 if (!(flags
& TDF_SLIM
))
2655 newline_and_indent (pp
, spc
+2);
2657 newline_and_indent (pp
, spc
+4);
2658 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2659 newline_and_indent (pp
, spc
+2);
2660 pp_right_brace (pp
);
2666 pp_string (pp
, "// predicted ");
2667 if (PREDICT_EXPR_OUTCOME (node
))
2668 pp_string (pp
, "likely by ");
2670 pp_string (pp
, "unlikely by ");
2671 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2672 pp_string (pp
, " predictor.");
2676 pp_string (pp
, "ANNOTATE_EXPR <");
2677 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2678 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2680 case annot_expr_ivdep_kind
:
2681 pp_string (pp
, ", ivdep");
2683 case annot_expr_unroll_kind
:
2684 pp_printf (pp
, ", unroll %d",
2685 (int) TREE_INT_CST_LOW (TREE_OPERAND (node
, 2)));
2687 case annot_expr_no_vector_kind
:
2688 pp_string (pp
, ", no-vector");
2690 case annot_expr_vector_kind
:
2691 pp_string (pp
, ", vector");
2693 case annot_expr_parallel_kind
:
2694 pp_string (pp
, ", parallel");
2703 pp_string (pp
, "return");
2704 op0
= TREE_OPERAND (node
, 0);
2708 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2709 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2712 dump_generic_node (pp
, op0
, spc
, flags
, false);
2717 pp_string (pp
, "if (");
2718 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2719 pp_string (pp
, ") break");
2723 pp_string (pp
, "switch (");
2724 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2725 pp_right_paren (pp
);
2726 if (!(flags
& TDF_SLIM
))
2728 newline_and_indent (pp
, spc
+2);
2730 if (SWITCH_BODY (node
))
2732 newline_and_indent (pp
, spc
+4);
2733 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2736 newline_and_indent (pp
, spc
+2);
2737 pp_right_brace (pp
);
2743 op0
= GOTO_DESTINATION (node
);
2744 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2746 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2747 if (strcmp (name
, "break") == 0
2748 || strcmp (name
, "continue") == 0)
2750 pp_string (pp
, name
);
2754 pp_string (pp
, "goto ");
2755 dump_generic_node (pp
, op0
, spc
, flags
, false);
2759 pp_string (pp
, "__asm__");
2760 if (ASM_VOLATILE_P (node
))
2761 pp_string (pp
, " __volatile__");
2763 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2765 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2767 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2768 if (ASM_CLOBBERS (node
))
2771 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2773 pp_right_paren (pp
);
2776 case CASE_LABEL_EXPR
:
2777 if (CASE_LOW (node
) && CASE_HIGH (node
))
2779 pp_string (pp
, "case ");
2780 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2781 pp_string (pp
, " ... ");
2782 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2784 else if (CASE_LOW (node
))
2786 pp_string (pp
, "case ");
2787 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2790 pp_string (pp
, "default");
2795 pp_string (pp
, "OBJ_TYPE_REF(");
2796 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2798 /* We omit the class type for -fcompare-debug because we may
2799 drop TYPE_BINFO early depending on debug info, and then
2800 virtual_method_call_p would return false, whereas when
2801 TYPE_BINFO is preserved it may still return true and then
2802 we'd print the class type. Compare tree and rtl dumps for
2803 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
2804 for example, at occurrences of OBJ_TYPE_REF. */
2805 if (!(flags
& (TDF_SLIM
| TDF_COMPARE_DEBUG
))
2806 && virtual_method_call_p (node
))
2808 pp_string (pp
, "(");
2809 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2810 pp_string (pp
, ")");
2812 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2814 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2815 pp_right_paren (pp
);
2819 if (SSA_NAME_IDENTIFIER (node
))
2821 if ((flags
& TDF_NOUID
)
2822 && SSA_NAME_VAR (node
)
2823 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
2824 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
2825 else if (! (flags
& TDF_GIMPLE
)
2826 || SSA_NAME_VAR (node
))
2827 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2831 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2832 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2833 pp_string (pp
, "(D)");
2834 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2835 pp_string (pp
, "(ab)");
2838 case WITH_SIZE_EXPR
:
2839 pp_string (pp
, "WITH_SIZE_EXPR <");
2840 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2841 pp_string (pp
, ", ");
2842 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2847 pp_string (pp
, "ASSERT_EXPR <");
2848 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2849 pp_string (pp
, ", ");
2850 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2855 pp_string (pp
, "scev_known");
2858 case SCEV_NOT_KNOWN
:
2859 pp_string (pp
, "scev_not_known");
2862 case POLYNOMIAL_CHREC
:
2864 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2865 pp_string (pp
, ", +, ");
2866 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2867 pp_printf (pp
, "}_%u", CHREC_VARIABLE (node
));
2871 case REALIGN_LOAD_EXPR
:
2872 pp_string (pp
, "REALIGN_LOAD <");
2873 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2874 pp_string (pp
, ", ");
2875 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2876 pp_string (pp
, ", ");
2877 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2882 pp_string (pp
, " VEC_COND_EXPR < ");
2883 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2884 pp_string (pp
, " , ");
2885 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2886 pp_string (pp
, " , ");
2887 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2888 pp_string (pp
, " > ");
2892 pp_string (pp
, " VEC_PERM_EXPR < ");
2893 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2894 pp_string (pp
, " , ");
2895 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2896 pp_string (pp
, " , ");
2897 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2898 pp_string (pp
, " > ");
2902 pp_string (pp
, " DOT_PROD_EXPR < ");
2903 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2904 pp_string (pp
, ", ");
2905 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2906 pp_string (pp
, ", ");
2907 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2908 pp_string (pp
, " > ");
2911 case WIDEN_MULT_PLUS_EXPR
:
2912 pp_string (pp
, " WIDEN_MULT_PLUS_EXPR < ");
2913 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2914 pp_string (pp
, ", ");
2915 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2916 pp_string (pp
, ", ");
2917 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2918 pp_string (pp
, " > ");
2921 case WIDEN_MULT_MINUS_EXPR
:
2922 pp_string (pp
, " WIDEN_MULT_MINUS_EXPR < ");
2923 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2924 pp_string (pp
, ", ");
2925 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2926 pp_string (pp
, ", ");
2927 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2928 pp_string (pp
, " > ");
2932 pp_string (pp
, "#pragma acc parallel");
2933 goto dump_omp_clauses_body
;
2936 pp_string (pp
, "#pragma acc kernels");
2937 goto dump_omp_clauses_body
;
2940 pp_string (pp
, "#pragma acc data");
2941 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2944 case OACC_HOST_DATA
:
2945 pp_string (pp
, "#pragma acc host_data");
2946 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2950 pp_string (pp
, "#pragma acc declare");
2951 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2955 pp_string (pp
, "#pragma acc update");
2956 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2959 case OACC_ENTER_DATA
:
2960 pp_string (pp
, "#pragma acc enter data");
2961 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2964 case OACC_EXIT_DATA
:
2965 pp_string (pp
, "#pragma acc exit data");
2966 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2970 pp_string (pp
, "#pragma acc cache");
2971 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2975 pp_string (pp
, "#pragma omp parallel");
2976 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2979 dump_omp_clauses_body
:
2980 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2984 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2986 newline_and_indent (pp
, spc
+ 2);
2988 newline_and_indent (pp
, spc
+ 4);
2989 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2990 newline_and_indent (pp
, spc
+ 2);
2991 pp_right_brace (pp
);
2997 pp_string (pp
, "#pragma omp task");
2998 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
3002 pp_string (pp
, "#pragma omp for");
3006 pp_string (pp
, "#pragma omp simd");
3009 case OMP_DISTRIBUTE
:
3010 pp_string (pp
, "#pragma omp distribute");
3014 pp_string (pp
, "#pragma omp taskloop");
3018 pp_string (pp
, "#pragma acc loop");
3022 pp_string (pp
, "#pragma omp teams");
3023 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
3026 case OMP_TARGET_DATA
:
3027 pp_string (pp
, "#pragma omp target data");
3028 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
3031 case OMP_TARGET_ENTER_DATA
:
3032 pp_string (pp
, "#pragma omp target enter data");
3033 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3037 case OMP_TARGET_EXIT_DATA
:
3038 pp_string (pp
, "#pragma omp target exit data");
3039 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3044 pp_string (pp
, "#pragma omp target");
3045 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3048 case OMP_TARGET_UPDATE
:
3049 pp_string (pp
, "#pragma omp target update");
3050 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3055 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3056 if (!(flags
& TDF_SLIM
))
3060 if (OMP_FOR_PRE_BODY (node
))
3062 newline_and_indent (pp
, spc
+ 2);
3065 newline_and_indent (pp
, spc
);
3066 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3069 if (OMP_FOR_INIT (node
))
3072 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3075 newline_and_indent (pp
, spc
);
3076 pp_string (pp
, "for (");
3077 dump_generic_node (pp
,
3078 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
3080 pp_string (pp
, "; ");
3081 dump_generic_node (pp
,
3082 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
3084 pp_string (pp
, "; ");
3085 dump_generic_node (pp
,
3086 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3088 pp_right_paren (pp
);
3091 if (OMP_FOR_BODY (node
))
3093 newline_and_indent (pp
, spc
+ 2);
3095 newline_and_indent (pp
, spc
+ 4);
3096 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3098 newline_and_indent (pp
, spc
+ 2);
3099 pp_right_brace (pp
);
3101 if (OMP_FOR_INIT (node
))
3102 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3103 if (OMP_FOR_PRE_BODY (node
))
3106 newline_and_indent (pp
, spc
+ 2);
3107 pp_right_brace (pp
);
3114 pp_string (pp
, "#pragma omp sections");
3115 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3119 pp_string (pp
, "#pragma omp section");
3123 pp_string (pp
, "#pragma omp master");
3127 pp_string (pp
, "#pragma omp taskgroup");
3131 pp_string (pp
, "#pragma omp ordered");
3132 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3136 pp_string (pp
, "#pragma omp critical");
3137 if (OMP_CRITICAL_NAME (node
))
3141 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3143 pp_right_paren (pp
);
3145 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3149 pp_string (pp
, "#pragma omp atomic");
3150 if (OMP_ATOMIC_SEQ_CST (node
))
3151 pp_string (pp
, " seq_cst");
3152 newline_and_indent (pp
, spc
+ 2);
3153 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3157 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3160 case OMP_ATOMIC_READ
:
3161 pp_string (pp
, "#pragma omp atomic read");
3162 if (OMP_ATOMIC_SEQ_CST (node
))
3163 pp_string (pp
, " seq_cst");
3164 newline_and_indent (pp
, spc
+ 2);
3165 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3169 case OMP_ATOMIC_CAPTURE_OLD
:
3170 case OMP_ATOMIC_CAPTURE_NEW
:
3171 pp_string (pp
, "#pragma omp atomic capture");
3172 if (OMP_ATOMIC_SEQ_CST (node
))
3173 pp_string (pp
, " seq_cst");
3174 newline_and_indent (pp
, spc
+ 2);
3175 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3179 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3183 pp_string (pp
, "#pragma omp single");
3184 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3188 dump_omp_clause (pp
, node
, spc
, flags
);
3192 case TRANSACTION_EXPR
:
3193 if (TRANSACTION_EXPR_OUTER (node
))
3194 pp_string (pp
, "__transaction_atomic [[outer]]");
3195 else if (TRANSACTION_EXPR_RELAXED (node
))
3196 pp_string (pp
, "__transaction_relaxed");
3198 pp_string (pp
, "__transaction_atomic");
3199 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3201 newline_and_indent (pp
, spc
);
3203 newline_and_indent (pp
, spc
+ 2);
3204 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3205 spc
+ 2, flags
, false);
3206 newline_and_indent (pp
, spc
);
3207 pp_right_brace (pp
);
3212 case VEC_SERIES_EXPR
:
3213 case VEC_WIDEN_MULT_HI_EXPR
:
3214 case VEC_WIDEN_MULT_LO_EXPR
:
3215 case VEC_WIDEN_MULT_EVEN_EXPR
:
3216 case VEC_WIDEN_MULT_ODD_EXPR
:
3217 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3218 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3220 for (str
= get_tree_code_name (code
); *str
; str
++)
3221 pp_character (pp
, TOUPPER (*str
));
3222 pp_string (pp
, " < ");
3223 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3224 pp_string (pp
, ", ");
3225 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3226 pp_string (pp
, " > ");
3229 case VEC_DUPLICATE_EXPR
:
3231 for (str
= get_tree_code_name (code
); *str
; str
++)
3232 pp_character (pp
, TOUPPER (*str
));
3233 pp_string (pp
, " < ");
3234 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3235 pp_string (pp
, " > ");
3238 case VEC_UNPACK_HI_EXPR
:
3239 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3240 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3241 pp_string (pp
, " > ");
3244 case VEC_UNPACK_LO_EXPR
:
3245 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3246 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3247 pp_string (pp
, " > ");
3250 case VEC_UNPACK_FLOAT_HI_EXPR
:
3251 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3252 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3253 pp_string (pp
, " > ");
3256 case VEC_UNPACK_FLOAT_LO_EXPR
:
3257 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3258 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3259 pp_string (pp
, " > ");
3262 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3263 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
3264 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3265 pp_string (pp
, " > ");
3268 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3269 pp_string (pp
, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
3270 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3271 pp_string (pp
, " > ");
3274 case VEC_PACK_TRUNC_EXPR
:
3275 pp_string (pp
, " VEC_PACK_TRUNC_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_SAT_EXPR
:
3283 pp_string (pp
, " VEC_PACK_SAT_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
, " > ");
3290 case VEC_PACK_FIX_TRUNC_EXPR
:
3291 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3292 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3293 pp_string (pp
, ", ");
3294 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3295 pp_string (pp
, " > ");
3298 case VEC_PACK_FLOAT_EXPR
:
3299 pp_string (pp
, " VEC_PACK_FLOAT_EXPR < ");
3300 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3301 pp_string (pp
, ", ");
3302 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3303 pp_string (pp
, " > ");
3307 dump_block_node (pp
, node
, spc
, flags
);
3310 case DEBUG_BEGIN_STMT
:
3311 pp_string (pp
, "# DEBUG BEGIN STMT");
3318 if (is_stmt
&& is_expr
)
3324 /* Print the declaration of a variable. */
3327 print_declaration (pretty_printer
*pp
, tree t
, int spc
, dump_flags_t flags
)
3331 if (TREE_CODE(t
) == NAMELIST_DECL
)
3333 pp_string(pp
, "namelist ");
3334 dump_decl_name (pp
, t
, flags
);
3339 if (TREE_CODE (t
) == TYPE_DECL
)
3340 pp_string (pp
, "typedef ");
3342 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3343 pp_string (pp
, "register ");
3345 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3346 pp_string (pp
, "extern ");
3347 else if (TREE_STATIC (t
))
3348 pp_string (pp
, "static ");
3350 /* Print the type and name. */
3351 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3355 /* Print array's type. */
3356 tmp
= TREE_TYPE (t
);
3357 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3358 tmp
= TREE_TYPE (tmp
);
3359 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3361 /* Print variable's name. */
3363 dump_generic_node (pp
, t
, spc
, flags
, false);
3365 /* Print the dimensions. */
3366 tmp
= TREE_TYPE (t
);
3367 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3369 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3370 tmp
= TREE_TYPE (tmp
);
3373 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3375 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3377 dump_decl_name (pp
, t
, flags
);
3378 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3382 /* Print type declaration. */
3383 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3385 /* Print variable's name. */
3387 dump_generic_node (pp
, t
, spc
, flags
, false);
3390 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
3392 pp_string (pp
, " __asm__ ");
3394 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3395 pp_right_paren (pp
);
3398 /* The initial value of a function serves to determine whether the function
3399 is declared or defined. So the following does not apply to function
3401 if (TREE_CODE (t
) != FUNCTION_DECL
)
3403 /* Print the initial value. */
3404 if (DECL_INITIAL (t
))
3409 if (!(flags
& TDF_SLIM
))
3410 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3412 pp_string (pp
, "<<< omitted >>>");
3416 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3418 pp_string (pp
, " [value-expr: ");
3419 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3420 pp_right_bracket (pp
);
3427 /* Prints a structure: name, fields, and methods.
3428 FIXME: Still incomplete. */
3431 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
3434 /* Print the name of the structure. */
3435 if (TYPE_NAME (node
))
3438 if (TREE_CODE (node
) == RECORD_TYPE
)
3439 pp_string (pp
, "struct ");
3440 else if ((TREE_CODE (node
) == UNION_TYPE
3441 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3442 pp_string (pp
, "union ");
3444 dump_generic_node (pp
, TYPE_NAME (node
), spc
, TDF_NONE
, false);
3447 /* Print the contents of the structure. */
3453 /* Print the fields of the structure. */
3456 tmp
= TYPE_FIELDS (node
);
3459 /* Avoid to print recursively the structure. */
3460 /* FIXME : Not implemented correctly...,
3461 what about the case when we have a cycle in the contain graph? ...
3462 Maybe this could be solved by looking at the scope in which the
3463 structure was declared. */
3464 if (TREE_TYPE (tmp
) != node
3465 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3466 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3468 print_declaration (pp
, tmp
, spc
+2, flags
);
3471 tmp
= DECL_CHAIN (tmp
);
3475 pp_right_brace (pp
);
3478 /* Return the priority of the operator CODE.
3480 From lowest to highest precedence with either left-to-right (L-R)
3481 or right-to-left (R-L) associativity]:
3484 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3496 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3497 15 [L-R] fn() [] -> .
3499 unary +, - and * have higher precedence than the corresponding binary
3503 op_code_prio (enum tree_code code
)
3520 case TRUTH_ORIF_EXPR
:
3523 case TRUTH_AND_EXPR
:
3524 case TRUTH_ANDIF_EXPR
:
3531 case TRUTH_XOR_EXPR
:
3548 case UNORDERED_EXPR
:
3559 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3560 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3561 case WIDEN_LSHIFT_EXPR
:
3564 case WIDEN_SUM_EXPR
:
3566 case POINTER_PLUS_EXPR
:
3567 case POINTER_DIFF_EXPR
:
3571 case VEC_WIDEN_MULT_HI_EXPR
:
3572 case VEC_WIDEN_MULT_LO_EXPR
:
3573 case WIDEN_MULT_EXPR
:
3575 case WIDEN_MULT_PLUS_EXPR
:
3576 case WIDEN_MULT_MINUS_EXPR
:
3578 case MULT_HIGHPART_EXPR
:
3579 case TRUNC_DIV_EXPR
:
3581 case FLOOR_DIV_EXPR
:
3582 case ROUND_DIV_EXPR
:
3584 case EXACT_DIV_EXPR
:
3585 case TRUNC_MOD_EXPR
:
3587 case FLOOR_MOD_EXPR
:
3588 case ROUND_MOD_EXPR
:
3591 case TRUTH_NOT_EXPR
:
3593 case POSTINCREMENT_EXPR
:
3594 case POSTDECREMENT_EXPR
:
3595 case PREINCREMENT_EXPR
:
3596 case PREDECREMENT_EXPR
:
3602 case FIX_TRUNC_EXPR
:
3608 case ARRAY_RANGE_REF
:
3612 /* Special expressions. */
3618 case VEC_UNPACK_HI_EXPR
:
3619 case VEC_UNPACK_LO_EXPR
:
3620 case VEC_UNPACK_FLOAT_HI_EXPR
:
3621 case VEC_UNPACK_FLOAT_LO_EXPR
:
3622 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3623 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3624 case VEC_PACK_TRUNC_EXPR
:
3625 case VEC_PACK_SAT_EXPR
:
3629 /* Return an arbitrarily high precedence to avoid surrounding single
3630 VAR_DECLs in ()s. */
3635 /* Return the priority of the operator OP. */
3638 op_prio (const_tree op
)
3640 enum tree_code code
;
3645 code
= TREE_CODE (op
);
3646 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3647 return op_prio (TREE_OPERAND (op
, 0));
3649 return op_code_prio (code
);
3652 /* Return the symbol associated with operator CODE. */
3655 op_symbol_code (enum tree_code code
)
3663 case TRUTH_ORIF_EXPR
:
3666 case TRUTH_AND_EXPR
:
3667 case TRUTH_ANDIF_EXPR
:
3673 case TRUTH_XOR_EXPR
:
3683 case UNORDERED_EXPR
:
3729 case WIDEN_LSHIFT_EXPR
:
3732 case POINTER_PLUS_EXPR
:
3738 case WIDEN_SUM_EXPR
:
3741 case WIDEN_MULT_EXPR
:
3744 case MULT_HIGHPART_EXPR
:
3749 case POINTER_DIFF_EXPR
:
3755 case TRUTH_NOT_EXPR
:
3762 case TRUNC_DIV_EXPR
:
3769 case FLOOR_DIV_EXPR
:
3772 case ROUND_DIV_EXPR
:
3775 case EXACT_DIV_EXPR
:
3778 case TRUNC_MOD_EXPR
:
3784 case FLOOR_MOD_EXPR
:
3787 case ROUND_MOD_EXPR
:
3790 case PREDECREMENT_EXPR
:
3793 case PREINCREMENT_EXPR
:
3796 case POSTDECREMENT_EXPR
:
3799 case POSTINCREMENT_EXPR
:
3809 return "<<< ??? >>>";
3813 /* Return the symbol associated with operator OP. */
3816 op_symbol (const_tree op
)
3818 return op_symbol_code (TREE_CODE (op
));
3821 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3822 the gimple_call_fn of a GIMPLE_CALL. */
3825 print_call_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
3829 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3830 op0
= TREE_OPERAND (op0
, 0);
3833 switch (TREE_CODE (op0
))
3838 dump_function_name (pp
, op0
, flags
);
3844 op0
= TREE_OPERAND (op0
, 0);
3849 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3850 pp_string (pp
, ") ? ");
3851 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3852 pp_string (pp
, " : ");
3853 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3857 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3858 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
3860 dump_generic_node (pp
, op0
, 0, flags
, false);
3864 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3866 op0
= TREE_OPERAND (op0
, 0);
3873 dump_generic_node (pp
, op0
, 0, flags
, false);
3881 /* Print the first N characters in the array STR, replacing non-printable
3882 characters (including embedded nuls) with unambiguous escape sequences. */
3885 pretty_print_string (pretty_printer
*pp
, const char *str
, unsigned n
)
3890 for ( ; n
; --n
, ++str
)
3895 pp_string (pp
, "\\b");
3899 pp_string (pp
, "\\f");
3903 pp_string (pp
, "\\n");
3907 pp_string (pp
, "\\r");
3911 pp_string (pp
, "\\t");
3915 pp_string (pp
, "\\v");
3919 pp_string (pp
, "\\\\");
3923 pp_string (pp
, "\\\"");
3927 pp_string (pp
, "\\'");
3931 if (str
[0] || n
> 1)
3933 if (!ISPRINT (str
[0]))
3936 sprintf (buf
, "\\x%02x", (unsigned char)str
[0]);
3937 pp_string (pp
, buf
);
3940 pp_character (pp
, str
[0]);
3948 maybe_init_pretty_print (FILE *file
)
3952 tree_pp
= new pretty_printer ();
3953 pp_needs_newline (tree_pp
) = true;
3954 pp_translate_identifiers (tree_pp
) = false;
3957 tree_pp
->buffer
->stream
= file
;
3961 newline_and_indent (pretty_printer
*pp
, int spc
)
3967 /* Handle the %K format for TEXT. Separate from default_tree_printer
3968 so it can also be used in front ends.
3969 The location LOC and BLOCK are expected to be extracted by the caller
3970 from the %K argument arg via EXPR_LOCATION(arg) and TREE_BLOCK(arg). */
3973 percent_K_format (text_info
*text
, location_t loc
, tree block
)
3975 text
->set_location (0, loc
, SHOW_RANGE_WITH_CARET
);
3976 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3977 *pp_ti_abstract_origin (text
) = NULL
;
3981 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3982 representing the outermost block of an inlined function.
3983 So walk the BLOCK tree until we hit such a scope. */
3985 && TREE_CODE (block
) == BLOCK
)
3987 if (inlined_function_outer_scope_p (block
))
3989 *pp_ti_abstract_origin (text
) = block
;
3992 block
= BLOCK_SUPERCONTEXT (block
);
3998 && TREE_CODE (block
) == BLOCK
3999 && BLOCK_ABSTRACT_ORIGIN (block
))
4001 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
4003 while (TREE_CODE (ao
) == BLOCK
4004 && BLOCK_ABSTRACT_ORIGIN (ao
)
4005 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
4006 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
4008 if (TREE_CODE (ao
) == FUNCTION_DECL
)
4010 *pp_ti_abstract_origin (text
) = block
;
4013 block
= BLOCK_SUPERCONTEXT (block
);
4017 /* Print the identifier ID to PRETTY-PRINTER. */
4020 pp_tree_identifier (pretty_printer
*pp
, tree id
)
4022 if (pp_translate_identifiers (pp
))
4024 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
4025 pp_append_text (pp
, text
, text
+ strlen (text
));
4028 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
4029 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
4032 /* A helper function that is used to dump function information before the
4036 dump_function_header (FILE *dump_file
, tree fdecl
, dump_flags_t flags
)
4038 const char *dname
, *aname
;
4039 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
4040 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
4042 dname
= lang_hooks
.decl_printable_name (fdecl
, 1);
4044 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
4045 aname
= (IDENTIFIER_POINTER
4046 (DECL_ASSEMBLER_NAME (fdecl
)));
4048 aname
= "<unset-asm-name>";
4050 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
4051 dname
, aname
, fun
->funcdef_no
);
4052 if (!(flags
& TDF_NOUID
))
4053 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
4056 fprintf (dump_file
, ", cgraph_uid=%d", node
->get_uid ());
4057 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
4058 node
->frequency
== NODE_FREQUENCY_HOT
4060 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
4061 ? " (unlikely executed)"
4062 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
4063 ? " (executed once)"
4067 fprintf (dump_file
, ")\n\n");
4070 /* Dump double_int D to pretty_printer PP. UNS is true
4071 if D is unsigned and false otherwise. */
4073 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4076 pp_wide_integer (pp
, d
.low
);
4077 else if (d
.fits_uhwi ())
4078 pp_unsigned_wide_integer (pp
, d
.low
);
4081 unsigned HOST_WIDE_INT low
= d
.low
;
4082 HOST_WIDE_INT high
= d
.high
;
4083 if (!uns
&& d
.is_negative ())
4086 high
= ~high
+ !low
;
4089 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4091 sprintf (pp_buffer (pp
)->digit_buffer
,
4092 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4093 (unsigned HOST_WIDE_INT
) high
, low
);
4094 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);