1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2018 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
29 #include "tree-pretty-print.h"
30 #include "stor-layout.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
34 #include "internal-fn.h"
35 #include "gomp-constants.h"
38 /* Local functions, macros and variables. */
39 static const char *op_symbol (const_tree
);
40 static void pretty_print_string (pretty_printer
*, const char*);
41 static void newline_and_indent (pretty_printer
*, int);
42 static void maybe_init_pretty_print (FILE *);
43 static void print_struct_decl (pretty_printer
*, const_tree
, int, dump_flags_t
);
44 static void do_niy (pretty_printer
*, const_tree
, dump_flags_t
);
46 #define INDENT(SPACE) do { \
47 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
49 #define NIY do_niy (pp, node, flags)
51 static pretty_printer
*tree_pp
;
53 /* Try to print something for an unknown tree code. */
56 do_niy (pretty_printer
*pp
, const_tree node
, dump_flags_t flags
)
60 pp_string (pp
, "<<< Unknown tree: ");
61 pp_string (pp
, get_tree_code_name (TREE_CODE (node
)));
65 len
= TREE_OPERAND_LENGTH (node
);
66 for (i
= 0; i
< len
; ++i
)
68 newline_and_indent (pp
, 2);
69 dump_generic_node (pp
, TREE_OPERAND (node
, i
), 2, flags
, false);
73 pp_string (pp
, " >>>");
76 /* Debugging function to print out a generic expression. */
79 debug_generic_expr (tree t
)
81 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
82 fprintf (stderr
, "\n");
85 /* Debugging function to print out a generic statement. */
88 debug_generic_stmt (tree t
)
90 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
91 fprintf (stderr
, "\n");
94 /* Debugging function to print out a chain of trees . */
97 debug_tree_chain (tree t
)
103 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
104 fprintf (stderr
, " ");
108 fprintf (stderr
, "... [cycled back to ");
109 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
110 fprintf (stderr
, "]");
114 fprintf (stderr
, "\n");
117 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
119 print_generic_decl (FILE *file
, tree decl
, dump_flags_t flags
)
121 maybe_init_pretty_print (file
);
122 print_declaration (tree_pp
, decl
, 2, flags
);
123 pp_write_text_to_stream (tree_pp
);
126 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
127 to show in the dump. See TDF_* in dumpfile.h. */
130 print_generic_stmt (FILE *file
, tree t
, dump_flags_t flags
)
132 maybe_init_pretty_print (file
);
133 dump_generic_node (tree_pp
, t
, 0, flags
, true);
134 pp_newline_and_flush (tree_pp
);
137 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
138 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
142 print_generic_stmt_indented (FILE *file
, tree t
, dump_flags_t flags
, int indent
)
146 maybe_init_pretty_print (file
);
148 for (i
= 0; i
< indent
; i
++)
150 dump_generic_node (tree_pp
, t
, indent
, flags
, true);
151 pp_newline_and_flush (tree_pp
);
154 /* Print a single expression T on file FILE. FLAGS specifies details to show
155 in the dump. See TDF_* in dumpfile.h. */
158 print_generic_expr (FILE *file
, tree t
, dump_flags_t flags
)
160 maybe_init_pretty_print (file
);
161 dump_generic_node (tree_pp
, t
, 0, flags
, false);
165 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
166 in it are replaced with Dxxxx, as long as they are at the start or
167 preceded by $ and at the end or followed by $. See make_fancy_name
171 dump_fancy_name (pretty_printer
*pp
, tree name
)
174 int length
= IDENTIFIER_LENGTH (name
);
175 const char *n
= IDENTIFIER_POINTER (name
);
182 && (n
== IDENTIFIER_POINTER (name
) || n
[-1] == '$'))
185 while (ISDIGIT (n
[l
]))
187 if (n
[l
] == '\0' || n
[l
] == '$')
200 pp_tree_identifier (pp
, name
);
204 char *str
= XNEWVEC (char, length
+ 1);
207 q
= n
= IDENTIFIER_POINTER (name
);
214 && (q
== IDENTIFIER_POINTER (name
) || q
[-1] == '$'))
217 while (ISDIGIT (q
[l
]))
219 if (q
[l
] == '\0' || q
[l
] == '$')
221 memcpy (p
, n
, q
- n
);
222 memcpy (p
+ (q
- n
), "Dxxxx", 5);
232 memcpy (p
, n
, IDENTIFIER_LENGTH (name
) - (n
- IDENTIFIER_POINTER (name
)));
234 if (pp_translate_identifiers (pp
))
236 const char *text
= identifier_to_locale (str
);
237 pp_append_text (pp
, text
, text
+ strlen (text
));
240 pp_append_text (pp
, str
, str
+ length
);
244 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
248 dump_decl_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
250 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_NOWAIT
:
470 pp_string (pp
, "nowait");
472 case OMP_CLAUSE_ORDERED
:
473 pp_string (pp
, "ordered");
474 if (OMP_CLAUSE_ORDERED_EXPR (clause
))
477 dump_generic_node (pp
, OMP_CLAUSE_ORDERED_EXPR (clause
),
483 case OMP_CLAUSE_DEFAULT
:
484 pp_string (pp
, "default(");
485 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
487 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
489 case OMP_CLAUSE_DEFAULT_SHARED
:
490 pp_string (pp
, "shared");
492 case OMP_CLAUSE_DEFAULT_NONE
:
493 pp_string (pp
, "none");
495 case OMP_CLAUSE_DEFAULT_PRIVATE
:
496 pp_string (pp
, "private");
498 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
499 pp_string (pp
, "firstprivate");
501 case OMP_CLAUSE_DEFAULT_PRESENT
:
502 pp_string (pp
, "present");
510 case OMP_CLAUSE_SCHEDULE
:
511 pp_string (pp
, "schedule(");
512 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
513 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
514 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
516 if (OMP_CLAUSE_SCHEDULE_KIND (clause
)
517 & OMP_CLAUSE_SCHEDULE_MONOTONIC
)
518 pp_string (pp
, "monotonic");
520 pp_string (pp
, "nonmonotonic");
521 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
526 if (OMP_CLAUSE_SCHEDULE_SIMD (clause
))
527 pp_string (pp
, "simd:");
529 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
) & OMP_CLAUSE_SCHEDULE_MASK
)
531 case OMP_CLAUSE_SCHEDULE_STATIC
:
532 pp_string (pp
, "static");
534 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
535 pp_string (pp
, "dynamic");
537 case OMP_CLAUSE_SCHEDULE_GUIDED
:
538 pp_string (pp
, "guided");
540 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
541 pp_string (pp
, "runtime");
543 case OMP_CLAUSE_SCHEDULE_AUTO
:
544 pp_string (pp
, "auto");
549 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
552 dump_generic_node (pp
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
558 case OMP_CLAUSE_UNTIED
:
559 pp_string (pp
, "untied");
562 case OMP_CLAUSE_COLLAPSE
:
563 pp_string (pp
, "collapse(");
564 dump_generic_node (pp
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
569 case OMP_CLAUSE_FINAL
:
570 pp_string (pp
, "final(");
571 dump_generic_node (pp
, OMP_CLAUSE_FINAL_EXPR (clause
),
576 case OMP_CLAUSE_MERGEABLE
:
577 pp_string (pp
, "mergeable");
580 case OMP_CLAUSE_LINEAR
:
581 pp_string (pp
, "linear(");
582 switch (OMP_CLAUSE_LINEAR_KIND (clause
))
584 case OMP_CLAUSE_LINEAR_DEFAULT
:
586 case OMP_CLAUSE_LINEAR_REF
:
587 pp_string (pp
, "ref(");
589 case OMP_CLAUSE_LINEAR_VAL
:
590 pp_string (pp
, "val(");
592 case OMP_CLAUSE_LINEAR_UVAL
:
593 pp_string (pp
, "uval(");
598 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
600 if (OMP_CLAUSE_LINEAR_KIND (clause
) != OMP_CLAUSE_LINEAR_DEFAULT
)
603 dump_generic_node (pp
, OMP_CLAUSE_LINEAR_STEP (clause
),
608 case OMP_CLAUSE_ALIGNED
:
609 pp_string (pp
, "aligned(");
610 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
612 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
615 dump_generic_node (pp
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
621 case OMP_CLAUSE_DEPEND
:
622 pp_string (pp
, "depend(");
623 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
625 case OMP_CLAUSE_DEPEND_IN
:
626 pp_string (pp
, "in");
628 case OMP_CLAUSE_DEPEND_OUT
:
629 pp_string (pp
, "out");
631 case OMP_CLAUSE_DEPEND_INOUT
:
632 pp_string (pp
, "inout");
634 case OMP_CLAUSE_DEPEND_SOURCE
:
635 pp_string (pp
, "source)");
637 case OMP_CLAUSE_DEPEND_SINK
:
638 pp_string (pp
, "sink:");
639 for (tree t
= OMP_CLAUSE_DECL (clause
); t
; t
= TREE_CHAIN (t
))
640 if (TREE_CODE (t
) == TREE_LIST
)
642 dump_generic_node (pp
, TREE_VALUE (t
), spc
, flags
, false);
643 if (TREE_PURPOSE (t
) != integer_zero_node
)
645 if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t
))
649 dump_generic_node (pp
, TREE_PURPOSE (t
), spc
, flags
,
663 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
669 pp_string (pp
, "map(");
670 switch (OMP_CLAUSE_MAP_KIND (clause
))
673 case GOMP_MAP_POINTER
:
674 pp_string (pp
, "alloc");
677 case GOMP_MAP_TO_PSET
:
678 pp_string (pp
, "to");
681 pp_string (pp
, "from");
683 case GOMP_MAP_TOFROM
:
684 pp_string (pp
, "tofrom");
686 case GOMP_MAP_FORCE_ALLOC
:
687 pp_string (pp
, "force_alloc");
689 case GOMP_MAP_FORCE_TO
:
690 pp_string (pp
, "force_to");
692 case GOMP_MAP_FORCE_FROM
:
693 pp_string (pp
, "force_from");
695 case GOMP_MAP_FORCE_TOFROM
:
696 pp_string (pp
, "force_tofrom");
698 case GOMP_MAP_FORCE_PRESENT
:
699 pp_string (pp
, "force_present");
701 case GOMP_MAP_DELETE
:
702 pp_string (pp
, "delete");
704 case GOMP_MAP_FORCE_DEVICEPTR
:
705 pp_string (pp
, "force_deviceptr");
707 case GOMP_MAP_ALWAYS_TO
:
708 pp_string (pp
, "always,to");
710 case GOMP_MAP_ALWAYS_FROM
:
711 pp_string (pp
, "always,from");
713 case GOMP_MAP_ALWAYS_TOFROM
:
714 pp_string (pp
, "always,tofrom");
716 case GOMP_MAP_RELEASE
:
717 pp_string (pp
, "release");
719 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
720 pp_string (pp
, "firstprivate");
722 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
723 pp_string (pp
, "firstprivate ref");
725 case GOMP_MAP_STRUCT
:
726 pp_string (pp
, "struct");
728 case GOMP_MAP_ALWAYS_POINTER
:
729 pp_string (pp
, "always_pointer");
731 case GOMP_MAP_DEVICE_RESIDENT
:
732 pp_string (pp
, "device_resident");
735 pp_string (pp
, "link");
741 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
744 if (OMP_CLAUSE_SIZE (clause
))
746 switch (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
747 ? OMP_CLAUSE_MAP_KIND (clause
) : GOMP_MAP_TO
)
749 case GOMP_MAP_POINTER
:
750 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
751 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
752 case GOMP_MAP_ALWAYS_POINTER
:
753 pp_string (pp
, " [pointer assign, bias: ");
755 case GOMP_MAP_TO_PSET
:
756 pp_string (pp
, " [pointer set, len: ");
759 pp_string (pp
, " [len: ");
762 dump_generic_node (pp
, OMP_CLAUSE_SIZE (clause
),
764 pp_right_bracket (pp
);
769 case OMP_CLAUSE_FROM
:
770 pp_string (pp
, "from(");
771 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
773 goto print_clause_size
;
776 pp_string (pp
, "to(");
777 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
779 goto print_clause_size
;
781 case OMP_CLAUSE__CACHE_
:
783 dump_generic_node (pp
, OMP_CLAUSE_DECL (clause
),
785 goto print_clause_size
;
787 case OMP_CLAUSE_NUM_TEAMS
:
788 pp_string (pp
, "num_teams(");
789 dump_generic_node (pp
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
794 case OMP_CLAUSE_THREAD_LIMIT
:
795 pp_string (pp
, "thread_limit(");
796 dump_generic_node (pp
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
801 case OMP_CLAUSE_DEVICE
:
802 pp_string (pp
, "device(");
803 dump_generic_node (pp
, OMP_CLAUSE_DEVICE_ID (clause
),
808 case OMP_CLAUSE_DIST_SCHEDULE
:
809 pp_string (pp
, "dist_schedule(static");
810 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
813 dump_generic_node (pp
,
814 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
820 case OMP_CLAUSE_PROC_BIND
:
821 pp_string (pp
, "proc_bind(");
822 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
824 case OMP_CLAUSE_PROC_BIND_MASTER
:
825 pp_string (pp
, "master");
827 case OMP_CLAUSE_PROC_BIND_CLOSE
:
828 pp_string (pp
, "close");
830 case OMP_CLAUSE_PROC_BIND_SPREAD
:
831 pp_string (pp
, "spread");
839 case OMP_CLAUSE_SAFELEN
:
840 pp_string (pp
, "safelen(");
841 dump_generic_node (pp
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
846 case OMP_CLAUSE_SIMDLEN
:
847 pp_string (pp
, "simdlen(");
848 dump_generic_node (pp
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
853 case OMP_CLAUSE_PRIORITY
:
854 pp_string (pp
, "priority(");
855 dump_generic_node (pp
, OMP_CLAUSE_PRIORITY_EXPR (clause
),
860 case OMP_CLAUSE_GRAINSIZE
:
861 pp_string (pp
, "grainsize(");
862 dump_generic_node (pp
, OMP_CLAUSE_GRAINSIZE_EXPR (clause
),
867 case OMP_CLAUSE_NUM_TASKS
:
868 pp_string (pp
, "num_tasks(");
869 dump_generic_node (pp
, OMP_CLAUSE_NUM_TASKS_EXPR (clause
),
874 case OMP_CLAUSE_HINT
:
875 pp_string (pp
, "hint(");
876 dump_generic_node (pp
, OMP_CLAUSE_HINT_EXPR (clause
),
881 case OMP_CLAUSE_DEFAULTMAP
:
882 pp_string (pp
, "defaultmap(tofrom:scalar)");
885 case OMP_CLAUSE__SIMDUID_
:
886 pp_string (pp
, "_simduid_(");
887 dump_generic_node (pp
, OMP_CLAUSE__SIMDUID__DECL (clause
),
892 case OMP_CLAUSE__SIMT_
:
893 pp_string (pp
, "_simt_");
896 case OMP_CLAUSE_GANG
:
897 pp_string (pp
, "gang");
898 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
)
900 pp_string (pp
, "(num: ");
901 dump_generic_node (pp
, OMP_CLAUSE_GANG_EXPR (clause
),
904 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
906 if (OMP_CLAUSE_GANG_EXPR (clause
) == NULL_TREE
)
910 pp_string (pp
, "static:");
911 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause
)
912 == integer_minus_one_node
)
913 pp_character (pp
, '*');
915 dump_generic_node (pp
, OMP_CLAUSE_GANG_STATIC_EXPR (clause
),
918 if (OMP_CLAUSE_GANG_EXPR (clause
) != NULL_TREE
919 || OMP_CLAUSE_GANG_STATIC_EXPR (clause
) != NULL_TREE
)
923 case OMP_CLAUSE_ASYNC
:
924 pp_string (pp
, "async");
925 if (OMP_CLAUSE_ASYNC_EXPR (clause
))
927 pp_character(pp
, '(');
928 dump_generic_node (pp
, OMP_CLAUSE_ASYNC_EXPR (clause
),
930 pp_character(pp
, ')');
934 case OMP_CLAUSE_AUTO
:
936 pp_string (pp
, omp_clause_code_name
[OMP_CLAUSE_CODE (clause
)]);
939 case OMP_CLAUSE_WAIT
:
940 pp_string (pp
, "wait(");
941 dump_generic_node (pp
, OMP_CLAUSE_WAIT_EXPR (clause
),
943 pp_character(pp
, ')');
946 case OMP_CLAUSE_WORKER
:
947 pp_string (pp
, "worker");
948 if (OMP_CLAUSE_WORKER_EXPR (clause
) != NULL_TREE
)
951 dump_generic_node (pp
, OMP_CLAUSE_WORKER_EXPR (clause
),
957 case OMP_CLAUSE_VECTOR
:
958 pp_string (pp
, "vector");
959 if (OMP_CLAUSE_VECTOR_EXPR (clause
) != NULL_TREE
)
962 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_EXPR (clause
),
968 case OMP_CLAUSE_NUM_GANGS
:
969 pp_string (pp
, "num_gangs(");
970 dump_generic_node (pp
, OMP_CLAUSE_NUM_GANGS_EXPR (clause
),
972 pp_character (pp
, ')');
975 case OMP_CLAUSE_NUM_WORKERS
:
976 pp_string (pp
, "num_workers(");
977 dump_generic_node (pp
, OMP_CLAUSE_NUM_WORKERS_EXPR (clause
),
979 pp_character (pp
, ')');
982 case OMP_CLAUSE_VECTOR_LENGTH
:
983 pp_string (pp
, "vector_length(");
984 dump_generic_node (pp
, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause
),
986 pp_character (pp
, ')');
989 case OMP_CLAUSE_INBRANCH
:
990 pp_string (pp
, "inbranch");
992 case OMP_CLAUSE_NOTINBRANCH
:
993 pp_string (pp
, "notinbranch");
996 pp_string (pp
, "for");
998 case OMP_CLAUSE_PARALLEL
:
999 pp_string (pp
, "parallel");
1001 case OMP_CLAUSE_SECTIONS
:
1002 pp_string (pp
, "sections");
1004 case OMP_CLAUSE_TASKGROUP
:
1005 pp_string (pp
, "taskgroup");
1007 case OMP_CLAUSE_NOGROUP
:
1008 pp_string (pp
, "nogroup");
1010 case OMP_CLAUSE_THREADS
:
1011 pp_string (pp
, "threads");
1013 case OMP_CLAUSE_SIMD
:
1014 pp_string (pp
, "simd");
1016 case OMP_CLAUSE_INDEPENDENT
:
1017 pp_string (pp
, "independent");
1019 case OMP_CLAUSE_TILE
:
1020 pp_string (pp
, "tile(");
1021 dump_generic_node (pp
, OMP_CLAUSE_TILE_LIST (clause
),
1023 pp_right_paren (pp
);
1026 case OMP_CLAUSE__GRIDDIM_
:
1027 pp_string (pp
, "_griddim_(");
1028 pp_unsigned_wide_integer (pp
, OMP_CLAUSE__GRIDDIM__DIMENSION (clause
));
1030 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__SIZE (clause
), spc
, flags
,
1033 dump_generic_node (pp
, OMP_CLAUSE__GRIDDIM__GROUP (clause
), spc
, flags
,
1035 pp_right_paren (pp
);
1039 /* Should never happen. */
1040 dump_generic_node (pp
, clause
, spc
, flags
, false);
1046 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1047 dump_generic_node. */
1050 dump_omp_clauses (pretty_printer
*pp
, tree clause
, int spc
, dump_flags_t flags
)
1058 dump_omp_clause (pp
, clause
, spc
, flags
);
1059 clause
= OMP_CLAUSE_CHAIN (clause
);
1067 /* Dump location LOC to PP. */
1070 dump_location (pretty_printer
*pp
, location_t loc
)
1072 expanded_location xloc
= expand_location (loc
);
1074 pp_left_bracket (pp
);
1077 pp_string (pp
, xloc
.file
);
1078 pp_string (pp
, ":");
1080 pp_decimal_int (pp
, xloc
.line
);
1082 pp_decimal_int (pp
, xloc
.column
);
1083 pp_string (pp
, "] ");
1087 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1088 dump_generic_node. */
1091 dump_block_node (pretty_printer
*pp
, tree block
, int spc
, dump_flags_t flags
)
1095 pp_printf (pp
, "BLOCK #%d ", BLOCK_NUMBER (block
));
1097 if (flags
& TDF_ADDRESS
)
1098 pp_printf (pp
, "[%p] ", (void *) block
);
1100 if (BLOCK_ABSTRACT (block
))
1101 pp_string (pp
, "[abstract] ");
1103 if (TREE_ASM_WRITTEN (block
))
1104 pp_string (pp
, "[written] ");
1106 if (flags
& TDF_SLIM
)
1109 if (BLOCK_SOURCE_LOCATION (block
))
1110 dump_location (pp
, BLOCK_SOURCE_LOCATION (block
));
1112 newline_and_indent (pp
, spc
+ 2);
1114 if (BLOCK_SUPERCONTEXT (block
))
1116 pp_string (pp
, "SUPERCONTEXT: ");
1117 dump_generic_node (pp
, BLOCK_SUPERCONTEXT (block
), 0,
1118 flags
| TDF_SLIM
, false);
1119 newline_and_indent (pp
, spc
+ 2);
1122 if (BLOCK_SUBBLOCKS (block
))
1124 pp_string (pp
, "SUBBLOCKS: ");
1125 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1127 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1130 newline_and_indent (pp
, spc
+ 2);
1133 if (BLOCK_CHAIN (block
))
1135 pp_string (pp
, "SIBLINGS: ");
1136 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
1138 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1141 newline_and_indent (pp
, spc
+ 2);
1144 if (BLOCK_VARS (block
))
1146 pp_string (pp
, "VARS: ");
1147 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
1149 dump_generic_node (pp
, t
, 0, flags
, false);
1152 newline_and_indent (pp
, spc
+ 2);
1155 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
1158 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
1160 pp_string (pp
, "NONLOCALIZED_VARS: ");
1161 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
1163 dump_generic_node (pp
, t
, 0, flags
, false);
1166 newline_and_indent (pp
, spc
+ 2);
1169 if (BLOCK_ABSTRACT_ORIGIN (block
))
1171 pp_string (pp
, "ABSTRACT_ORIGIN: ");
1172 dump_generic_node (pp
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
1173 flags
| TDF_SLIM
, false);
1174 newline_and_indent (pp
, spc
+ 2);
1177 if (BLOCK_FRAGMENT_ORIGIN (block
))
1179 pp_string (pp
, "FRAGMENT_ORIGIN: ");
1180 dump_generic_node (pp
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
1181 flags
| TDF_SLIM
, false);
1182 newline_and_indent (pp
, spc
+ 2);
1185 if (BLOCK_FRAGMENT_CHAIN (block
))
1187 pp_string (pp
, "FRAGMENT_CHAIN: ");
1188 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
1190 dump_generic_node (pp
, t
, 0, flags
| TDF_SLIM
, false);
1193 newline_and_indent (pp
, spc
+ 2);
1198 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1199 indent. FLAGS specifies details to show in the dump (see TDF_* in
1200 dumpfile.h). If IS_STMT is true, the object printed is considered
1201 to be a statement and it is terminated by ';' if appropriate. */
1204 dump_generic_node (pretty_printer
*pp
, tree node
, int spc
, dump_flags_t flags
,
1211 enum tree_code code
;
1213 if (node
== NULL_TREE
)
1216 is_expr
= EXPR_P (node
);
1218 if (is_stmt
&& (flags
& TDF_STMTADDR
))
1219 pp_printf (pp
, "<&%p> ", (void *)node
);
1221 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
1222 dump_location (pp
, EXPR_LOCATION (node
));
1224 code
= TREE_CODE (node
);
1228 pp_string (pp
, "<<< error >>>");
1231 case IDENTIFIER_NODE
:
1232 pp_tree_identifier (pp
, node
);
1236 while (node
&& node
!= error_mark_node
)
1238 if (TREE_PURPOSE (node
))
1240 dump_generic_node (pp
, TREE_PURPOSE (node
), spc
, flags
, false);
1243 dump_generic_node (pp
, TREE_VALUE (node
), spc
, flags
, false);
1244 node
= TREE_CHAIN (node
);
1245 if (node
&& TREE_CODE (node
) == TREE_LIST
)
1254 dump_generic_node (pp
, BINFO_TYPE (node
), spc
, flags
, false);
1260 if (TREE_VEC_LENGTH (node
) > 0)
1262 size_t len
= TREE_VEC_LENGTH (node
);
1263 for (i
= 0; i
< len
- 1; i
++)
1265 dump_generic_node (pp
, TREE_VEC_ELT (node
, i
), spc
, flags
,
1270 dump_generic_node (pp
, TREE_VEC_ELT (node
, len
- 1), spc
,
1277 case POINTER_BOUNDS_TYPE
:
1280 case FIXED_POINT_TYPE
:
1286 unsigned int quals
= TYPE_QUALS (node
);
1287 enum tree_code_class tclass
;
1289 if (quals
& TYPE_QUAL_ATOMIC
)
1290 pp_string (pp
, "atomic ");
1291 if (quals
& TYPE_QUAL_CONST
)
1292 pp_string (pp
, "const ");
1293 else if (quals
& TYPE_QUAL_VOLATILE
)
1294 pp_string (pp
, "volatile ");
1295 else if (quals
& TYPE_QUAL_RESTRICT
)
1296 pp_string (pp
, "restrict ");
1298 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1300 pp_string (pp
, "<address-space-");
1301 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1302 pp_string (pp
, "> ");
1305 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
1307 if (tclass
== tcc_declaration
)
1309 if (DECL_NAME (node
))
1310 dump_decl_name (pp
, node
, flags
);
1312 pp_string (pp
, "<unnamed type decl>");
1314 else if (tclass
== tcc_type
)
1316 if (TYPE_NAME (node
))
1318 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
1319 pp_tree_identifier (pp
, TYPE_NAME (node
));
1320 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
1321 && DECL_NAME (TYPE_NAME (node
)))
1322 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1324 pp_string (pp
, "<unnamed type>");
1326 else if (TREE_CODE (node
) == VECTOR_TYPE
)
1328 pp_string (pp
, "vector");
1330 pp_wide_integer (pp
, TYPE_VECTOR_SUBPARTS (node
));
1331 pp_string (pp
, ") ");
1332 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1334 else if (TREE_CODE (node
) == INTEGER_TYPE
)
1336 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
1337 pp_string (pp
, (TYPE_UNSIGNED (node
)
1340 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
1341 pp_string (pp
, (TYPE_UNSIGNED (node
)
1344 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
1345 pp_string (pp
, (TYPE_UNSIGNED (node
)
1348 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
1349 pp_string (pp
, (TYPE_UNSIGNED (node
)
1352 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
1353 pp_string (pp
, (TYPE_UNSIGNED (node
)
1354 ? "unsigned long long"
1355 : "signed long long"));
1356 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
1357 && pow2p_hwi (TYPE_PRECISION (node
)))
1359 pp_string (pp
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
1360 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1361 pp_string (pp
, "_t");
1365 pp_string (pp
, (TYPE_UNSIGNED (node
)
1366 ? "<unnamed-unsigned:"
1367 : "<unnamed-signed:"));
1368 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1372 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
1374 pp_string (pp
, "__complex__ ");
1375 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1377 else if (TREE_CODE (node
) == REAL_TYPE
)
1379 pp_string (pp
, "<float:");
1380 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1383 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1385 pp_string (pp
, "<fixed-point-");
1386 pp_string (pp
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1387 pp_decimal_int (pp
, TYPE_PRECISION (node
));
1390 else if (TREE_CODE (node
) == VOID_TYPE
)
1391 pp_string (pp
, "void");
1393 pp_string (pp
, "<unnamed type>");
1399 case REFERENCE_TYPE
:
1400 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1402 if (TREE_TYPE (node
) == NULL
)
1404 pp_string (pp
, str
);
1405 pp_string (pp
, "<null type>");
1407 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1409 tree fnode
= TREE_TYPE (node
);
1411 dump_generic_node (pp
, TREE_TYPE (fnode
), spc
, flags
, false);
1414 pp_string (pp
, str
);
1415 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1416 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1417 else if (flags
& TDF_NOUID
)
1418 pp_printf (pp
, "<Txxxx>");
1420 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1422 pp_right_paren (pp
);
1423 dump_function_declaration (pp
, fnode
, spc
, flags
);
1427 unsigned int quals
= TYPE_QUALS (node
);
1429 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1431 pp_string (pp
, str
);
1433 if (quals
& TYPE_QUAL_CONST
)
1434 pp_string (pp
, " const");
1435 if (quals
& TYPE_QUAL_VOLATILE
)
1436 pp_string (pp
, " volatile");
1437 if (quals
& TYPE_QUAL_RESTRICT
)
1438 pp_string (pp
, " restrict");
1440 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1442 pp_string (pp
, " <address-space-");
1443 pp_decimal_int (pp
, TYPE_ADDR_SPACE (node
));
1447 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1448 pp_string (pp
, " {ref-all}");
1458 if (flags
& TDF_GIMPLE
)
1460 pp_string (pp
, "__MEM <");
1461 dump_generic_node (pp
, TREE_TYPE (node
),
1462 spc
, flags
| TDF_SLIM
, false);
1463 if (TYPE_ALIGN (TREE_TYPE (node
))
1464 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node
))))
1466 pp_string (pp
, ", ");
1467 pp_decimal_int (pp
, TYPE_ALIGN (TREE_TYPE (node
)));
1470 pp_string (pp
, " (");
1471 if (TREE_TYPE (TREE_OPERAND (node
, 0))
1472 != TREE_TYPE (TREE_OPERAND (node
, 1)))
1475 dump_generic_node (pp
, TREE_TYPE (TREE_OPERAND (node
, 1)),
1476 spc
, flags
| TDF_SLIM
, false);
1477 pp_right_paren (pp
);
1479 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1480 spc
, flags
| TDF_SLIM
, false);
1481 if (! integer_zerop (TREE_OPERAND (node
, 1)))
1483 pp_string (pp
, " + ");
1484 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1485 spc
, flags
| TDF_SLIM
, false);
1487 pp_right_paren (pp
);
1489 else if (integer_zerop (TREE_OPERAND (node
, 1))
1490 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1491 infer them and MEM_ATTR caching will share MEM_REFs
1492 with differently-typed op0s. */
1493 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1494 /* Released SSA_NAMES have no TREE_TYPE. */
1495 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1496 /* Same pointer types, but ignoring POINTER_TYPE vs.
1498 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1499 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1500 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1501 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1502 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1503 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1504 /* Same value types ignoring qualifiers. */
1505 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1506 == TYPE_MAIN_VARIANT
1507 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1)))))
1508 && (!(flags
& TDF_ALIAS
)
1509 || MR_DEPENDENCE_CLIQUE (node
) == 0))
1511 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1514 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1518 dump_generic_node (pp
,
1519 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1526 pp_string (pp
, "MEM[");
1528 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1529 dump_generic_node (pp
, ptype
,
1530 spc
, flags
| TDF_SLIM
, false);
1531 pp_right_paren (pp
);
1532 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
1534 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1536 pp_string (pp
, " + ");
1537 dump_generic_node (pp
, TREE_OPERAND (node
, 1),
1540 if ((flags
& TDF_ALIAS
)
1541 && MR_DEPENDENCE_CLIQUE (node
) != 0)
1543 pp_string (pp
, " clique ");
1544 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_CLIQUE (node
));
1545 pp_string (pp
, " base ");
1546 pp_unsigned_wide_integer (pp
, MR_DEPENDENCE_BASE (node
));
1548 pp_right_bracket (pp
);
1553 case TARGET_MEM_REF
:
1555 const char *sep
= "";
1558 pp_string (pp
, "MEM[");
1560 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1562 pp_string (pp
, sep
);
1564 pp_string (pp
, "symbol: ");
1565 dump_generic_node (pp
, TREE_OPERAND (TMR_BASE (node
), 0),
1570 pp_string (pp
, sep
);
1572 pp_string (pp
, "base: ");
1573 dump_generic_node (pp
, TMR_BASE (node
), spc
, flags
, false);
1575 tmp
= TMR_INDEX2 (node
);
1578 pp_string (pp
, sep
);
1580 pp_string (pp
, "base: ");
1581 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1583 tmp
= TMR_INDEX (node
);
1586 pp_string (pp
, sep
);
1588 pp_string (pp
, "index: ");
1589 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1591 tmp
= TMR_STEP (node
);
1594 pp_string (pp
, sep
);
1596 pp_string (pp
, "step: ");
1597 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1599 tmp
= TMR_OFFSET (node
);
1602 pp_string (pp
, sep
);
1604 pp_string (pp
, "offset: ");
1605 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1607 pp_right_bracket (pp
);
1615 /* Print the innermost component type. */
1616 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1617 tmp
= TREE_TYPE (tmp
))
1619 dump_generic_node (pp
, tmp
, spc
, flags
, false);
1621 /* Print the dimensions. */
1622 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1623 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
1629 case QUAL_UNION_TYPE
:
1631 unsigned int quals
= TYPE_QUALS (node
);
1633 if (quals
& TYPE_QUAL_ATOMIC
)
1634 pp_string (pp
, "atomic ");
1635 if (quals
& TYPE_QUAL_CONST
)
1636 pp_string (pp
, "const ");
1637 if (quals
& TYPE_QUAL_VOLATILE
)
1638 pp_string (pp
, "volatile ");
1640 /* Print the name of the structure. */
1641 if (TREE_CODE (node
) == RECORD_TYPE
)
1642 pp_string (pp
, "struct ");
1643 else if (TREE_CODE (node
) == UNION_TYPE
)
1644 pp_string (pp
, "union ");
1646 if (TYPE_NAME (node
))
1647 dump_generic_node (pp
, TYPE_NAME (node
), spc
, flags
, false);
1648 else if (!(flags
& TDF_SLIM
))
1649 /* FIXME: If we eliminate the 'else' above and attempt
1650 to show the fields for named types, we may get stuck
1651 following a cycle of pointers to structs. The alleged
1652 self-reference check in print_struct_decl will not detect
1653 cycles involving more than one pointer or struct type. */
1654 print_struct_decl (pp
, node
, spc
, flags
);
1663 if (flags
& TDF_GIMPLE
1664 && (POINTER_TYPE_P (TREE_TYPE (node
))
1665 || (TYPE_PRECISION (TREE_TYPE (node
))
1666 < TYPE_PRECISION (integer_type_node
))
1667 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1669 pp_string (pp
, "_Literal (");
1670 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1671 pp_string (pp
, ") ");
1673 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
1674 && ! (flags
& TDF_GIMPLE
))
1676 /* In the case of a pointer, one may want to divide by the
1677 size of the pointed-to type. Unfortunately, this not
1678 straightforward. The C front-end maps expressions
1683 in such a way that the two INTEGER_CST nodes for "5" have
1684 different values but identical types. In the latter
1685 case, the 5 is multiplied by sizeof (int) in c-common.c
1686 (pointer_int_sum) to convert it to a byte address, and
1687 yet the type of the node is left unchanged. Argh. What
1688 is consistent though is that the number value corresponds
1689 to bytes (UNITS) offset.
1691 NB: Neither of the following divisors can be trivially
1692 used to recover the original literal:
1694 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1695 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1696 pp_wide_integer (pp
, TREE_INT_CST_LOW (node
));
1697 pp_string (pp
, "B"); /* pseudo-unit */
1699 else if (tree_fits_shwi_p (node
))
1700 pp_wide_integer (pp
, tree_to_shwi (node
));
1701 else if (tree_fits_uhwi_p (node
))
1702 pp_unsigned_wide_integer (pp
, tree_to_uhwi (node
));
1705 wide_int val
= wi::to_wide (node
);
1707 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1712 print_hex (val
, pp_buffer (pp
)->digit_buffer
);
1713 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
1715 if ((flags
& TDF_GIMPLE
)
1716 && ! (POINTER_TYPE_P (TREE_TYPE (node
))
1717 || (TYPE_PRECISION (TREE_TYPE (node
))
1718 < TYPE_PRECISION (integer_type_node
))
1719 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node
))) == -1))
1721 if (TYPE_UNSIGNED (TREE_TYPE (node
)))
1722 pp_character (pp
, 'u');
1723 if (TYPE_PRECISION (TREE_TYPE (node
))
1724 == TYPE_PRECISION (unsigned_type_node
))
1726 else if (TYPE_PRECISION (TREE_TYPE (node
))
1727 == TYPE_PRECISION (long_unsigned_type_node
))
1728 pp_character (pp
, 'l');
1729 else if (TYPE_PRECISION (TREE_TYPE (node
))
1730 == TYPE_PRECISION (long_long_unsigned_type_node
))
1731 pp_string (pp
, "ll");
1733 if (TREE_OVERFLOW (node
))
1734 pp_string (pp
, "(OVF)");
1738 pp_string (pp
, "POLY_INT_CST [");
1739 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, 0), spc
, flags
, false);
1740 for (unsigned int i
= 1; i
< NUM_POLY_INT_COEFFS
; ++i
)
1742 pp_string (pp
, ", ");
1743 dump_generic_node (pp
, POLY_INT_CST_COEFF (node
, i
),
1746 pp_string (pp
, "]");
1750 /* Code copied from print_node. */
1753 if (TREE_OVERFLOW (node
))
1754 pp_string (pp
, " overflow");
1756 d
= TREE_REAL_CST (node
);
1757 if (REAL_VALUE_ISINF (d
))
1758 pp_string (pp
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1759 else if (REAL_VALUE_ISNAN (d
))
1760 pp_string (pp
, " Nan");
1764 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1765 pp_string (pp
, string
);
1773 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1774 pp_string (pp
, string
);
1779 pp_string (pp
, "__complex__ (");
1780 dump_generic_node (pp
, TREE_REALPART (node
), spc
, flags
, false);
1781 pp_string (pp
, ", ");
1782 dump_generic_node (pp
, TREE_IMAGPART (node
), spc
, flags
, false);
1783 pp_right_paren (pp
);
1787 pp_string (pp
, "\"");
1788 pretty_print_string (pp
, TREE_STRING_POINTER (node
));
1789 pp_string (pp
, "\"");
1795 pp_string (pp
, "{ ");
1796 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1799 pp_string (pp
, ", ");
1800 dump_generic_node (pp
, VECTOR_CST_ELT (node
, i
),
1803 pp_string (pp
, " }");
1809 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1811 if (TREE_CODE (node
) == METHOD_TYPE
)
1813 if (TYPE_METHOD_BASETYPE (node
))
1814 dump_decl_name (pp
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1817 pp_string (pp
, "<null method basetype>");
1818 pp_colon_colon (pp
);
1820 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1821 dump_decl_name (pp
, TYPE_NAME (node
), flags
);
1822 else if (flags
& TDF_NOUID
)
1823 pp_printf (pp
, "<Txxxx>");
1825 pp_printf (pp
, "<T%x>", TYPE_UID (node
));
1826 dump_function_declaration (pp
, node
, spc
, flags
);
1831 dump_decl_name (pp
, node
, flags
);
1835 if (DECL_NAME (node
))
1836 dump_decl_name (pp
, node
, flags
);
1837 else if (LABEL_DECL_UID (node
) != -1)
1839 if (flags
& TDF_GIMPLE
)
1840 pp_printf (pp
, "L%d", (int) LABEL_DECL_UID (node
));
1842 pp_printf (pp
, "<L%d>", (int) LABEL_DECL_UID (node
));
1846 if (flags
& TDF_NOUID
)
1847 pp_string (pp
, "<D.xxxx>");
1850 if (flags
& TDF_GIMPLE
)
1851 pp_printf (pp
, "<D%u>", DECL_UID (node
));
1853 pp_printf (pp
, "<D.%u>", DECL_UID (node
));
1859 if (DECL_IS_BUILTIN (node
))
1861 /* Don't print the declaration of built-in types. */
1864 if (DECL_NAME (node
))
1865 dump_decl_name (pp
, node
, flags
);
1866 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1868 pp_string (pp
, (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1869 ? "union" : "struct "));
1870 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
1873 pp_string (pp
, "<anon>");
1879 case DEBUG_EXPR_DECL
:
1880 case NAMESPACE_DECL
:
1882 dump_decl_name (pp
, node
, flags
);
1886 pp_string (pp
, "<retval>");
1890 op0
= TREE_OPERAND (node
, 0);
1893 && (TREE_CODE (op0
) == INDIRECT_REF
1894 || (TREE_CODE (op0
) == MEM_REF
1895 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1896 && integer_zerop (TREE_OPERAND (op0
, 1))
1897 /* Dump the types of INTEGER_CSTs explicitly, for we
1898 can't infer them and MEM_ATTR caching will share
1899 MEM_REFs with differently-typed op0s. */
1900 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1901 /* Released SSA_NAMES have no TREE_TYPE. */
1902 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1903 /* Same pointer types, but ignoring POINTER_TYPE vs.
1905 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1906 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1907 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1908 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1909 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1910 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1911 /* Same value types ignoring qualifiers. */
1912 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1913 == TYPE_MAIN_VARIANT
1914 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1)))))
1915 && MR_DEPENDENCE_CLIQUE (op0
) == 0)))
1917 op0
= TREE_OPERAND (op0
, 0);
1920 if (op_prio (op0
) < op_prio (node
))
1922 dump_generic_node (pp
, op0
, spc
, flags
, false);
1923 if (op_prio (op0
) < op_prio (node
))
1924 pp_right_paren (pp
);
1925 pp_string (pp
, str
);
1926 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1927 op0
= component_ref_field_offset (node
);
1928 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1930 pp_string (pp
, "{off: ");
1931 dump_generic_node (pp
, op0
, spc
, flags
, false);
1932 pp_right_brace (pp
);
1937 pp_string (pp
, "BIT_FIELD_REF <");
1938 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1939 pp_string (pp
, ", ");
1940 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1941 pp_string (pp
, ", ");
1942 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1946 case BIT_INSERT_EXPR
:
1947 pp_string (pp
, "BIT_INSERT_EXPR <");
1948 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1949 pp_string (pp
, ", ");
1950 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1951 pp_string (pp
, ", ");
1952 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1953 pp_string (pp
, " (");
1954 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node
, 1))))
1956 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node
, 1))));
1958 dump_generic_node (pp
, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node
, 1))),
1960 pp_string (pp
, " bits)>");
1964 case ARRAY_RANGE_REF
:
1965 op0
= TREE_OPERAND (node
, 0);
1966 if (op_prio (op0
) < op_prio (node
))
1968 dump_generic_node (pp
, op0
, spc
, flags
, false);
1969 if (op_prio (op0
) < op_prio (node
))
1970 pp_right_paren (pp
);
1971 pp_left_bracket (pp
);
1972 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1973 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1974 pp_string (pp
, " ...");
1975 pp_right_bracket (pp
);
1977 op0
= array_ref_low_bound (node
);
1978 op1
= array_ref_element_size (node
);
1980 if (!integer_zerop (op0
)
1981 || TREE_OPERAND (node
, 2)
1982 || TREE_OPERAND (node
, 3))
1984 pp_string (pp
, "{lb: ");
1985 dump_generic_node (pp
, op0
, spc
, flags
, false);
1986 pp_string (pp
, " sz: ");
1987 dump_generic_node (pp
, op1
, spc
, flags
, false);
1988 pp_right_brace (pp
);
1994 unsigned HOST_WIDE_INT ix
;
1996 bool is_struct_init
= false;
1997 bool is_array_init
= false;
2000 if (TREE_CLOBBER_P (node
))
2001 pp_string (pp
, "CLOBBER");
2002 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
2003 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
2004 is_struct_init
= true;
2005 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
2006 && TYPE_DOMAIN (TREE_TYPE (node
))
2007 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
2008 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
2011 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
2012 is_array_init
= true;
2013 curidx
= wi::to_widest (minv
);
2015 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
2022 dump_generic_node (pp
, field
, spc
, flags
, false);
2025 else if (is_array_init
2026 && (TREE_CODE (field
) != INTEGER_CST
2027 || curidx
!= wi::to_widest (field
)))
2029 pp_left_bracket (pp
);
2030 if (TREE_CODE (field
) == RANGE_EXPR
)
2032 dump_generic_node (pp
, TREE_OPERAND (field
, 0), spc
,
2034 pp_string (pp
, " ... ");
2035 dump_generic_node (pp
, TREE_OPERAND (field
, 1), spc
,
2037 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
2038 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
2041 dump_generic_node (pp
, field
, spc
, flags
, false);
2042 if (TREE_CODE (field
) == INTEGER_CST
)
2043 curidx
= wi::to_widest (field
);
2044 pp_string (pp
, "]=");
2049 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
2050 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
2051 val
= TREE_OPERAND (val
, 0);
2052 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
2053 dump_decl_name (pp
, val
, flags
);
2055 dump_generic_node (pp
, val
, spc
, flags
, false);
2056 if (ix
!= CONSTRUCTOR_NELTS (node
) - 1)
2062 pp_right_brace (pp
);
2069 if (flags
& TDF_SLIM
)
2071 pp_string (pp
, "<COMPOUND_EXPR>");
2075 dump_generic_node (pp
, TREE_OPERAND (node
, 0),
2076 spc
, flags
, !(flags
& TDF_SLIM
));
2077 if (flags
& TDF_SLIM
)
2078 newline_and_indent (pp
, spc
);
2085 for (tp
= &TREE_OPERAND (node
, 1);
2086 TREE_CODE (*tp
) == COMPOUND_EXPR
;
2087 tp
= &TREE_OPERAND (*tp
, 1))
2089 dump_generic_node (pp
, TREE_OPERAND (*tp
, 0),
2090 spc
, flags
, !(flags
& TDF_SLIM
));
2091 if (flags
& TDF_SLIM
)
2092 newline_and_indent (pp
, spc
);
2100 dump_generic_node (pp
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
2104 case STATEMENT_LIST
:
2106 tree_stmt_iterator si
;
2109 if (flags
& TDF_SLIM
)
2111 pp_string (pp
, "<STATEMENT_LIST>");
2115 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
2118 newline_and_indent (pp
, spc
);
2121 dump_generic_node (pp
, tsi_stmt (si
), spc
, flags
, true);
2128 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
,
2133 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
,
2138 pp_string (pp
, "TARGET_EXPR <");
2139 dump_generic_node (pp
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
2142 dump_generic_node (pp
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
2147 print_declaration (pp
, DECL_EXPR_DECL (node
), spc
, flags
);
2152 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
2154 pp_string (pp
, "if (");
2155 dump_generic_node (pp
, COND_EXPR_COND (node
), spc
, flags
, false);
2156 pp_right_paren (pp
);
2157 /* The lowered cond_exprs should always be printed in full. */
2158 if (COND_EXPR_THEN (node
)
2159 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
2160 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
2161 && COND_EXPR_ELSE (node
)
2162 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
2163 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
2166 dump_generic_node (pp
, COND_EXPR_THEN (node
),
2168 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2170 pp_string (pp
, " else ");
2171 dump_generic_node (pp
, COND_EXPR_ELSE (node
),
2175 else if (!(flags
& TDF_SLIM
))
2177 /* Output COND_EXPR_THEN. */
2178 if (COND_EXPR_THEN (node
))
2180 newline_and_indent (pp
, spc
+2);
2182 newline_and_indent (pp
, spc
+4);
2183 dump_generic_node (pp
, COND_EXPR_THEN (node
), spc
+4,
2185 newline_and_indent (pp
, spc
+2);
2186 pp_right_brace (pp
);
2189 /* Output COND_EXPR_ELSE. */
2190 if (COND_EXPR_ELSE (node
)
2191 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
2193 newline_and_indent (pp
, spc
);
2194 pp_string (pp
, "else");
2195 newline_and_indent (pp
, spc
+2);
2197 newline_and_indent (pp
, spc
+4);
2198 dump_generic_node (pp
, COND_EXPR_ELSE (node
), spc
+4,
2200 newline_and_indent (pp
, spc
+2);
2201 pp_right_brace (pp
);
2208 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2212 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2216 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2222 if (!(flags
& TDF_SLIM
))
2224 if (BIND_EXPR_VARS (node
))
2228 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
2230 print_declaration (pp
, op0
, spc
+2, flags
);
2235 newline_and_indent (pp
, spc
+2);
2236 dump_generic_node (pp
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
2237 newline_and_indent (pp
, spc
);
2238 pp_right_brace (pp
);
2244 if (CALL_EXPR_FN (node
) != NULL_TREE
)
2245 print_call_name (pp
, CALL_EXPR_FN (node
), flags
);
2247 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (node
)));
2249 /* Print parameters. */
2254 call_expr_arg_iterator iter
;
2255 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
2257 dump_generic_node (pp
, arg
, spc
, flags
, false);
2258 if (more_call_expr_args_p (&iter
))
2265 if (CALL_EXPR_VA_ARG_PACK (node
))
2267 if (call_expr_nargs (node
) > 0)
2272 pp_string (pp
, "__builtin_va_arg_pack ()");
2274 pp_right_paren (pp
);
2276 op1
= CALL_EXPR_STATIC_CHAIN (node
);
2279 pp_string (pp
, " [static-chain: ");
2280 dump_generic_node (pp
, op1
, spc
, flags
, false);
2281 pp_right_bracket (pp
);
2284 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
2285 pp_string (pp
, " [return slot optimization]");
2286 if (CALL_EXPR_TAILCALL (node
))
2287 pp_string (pp
, " [tail call]");
2290 case WITH_CLEANUP_EXPR
:
2294 case CLEANUP_POINT_EXPR
:
2295 pp_string (pp
, "<<cleanup_point ");
2296 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2297 pp_string (pp
, ">>");
2300 case PLACEHOLDER_EXPR
:
2301 pp_string (pp
, "<PLACEHOLDER_EXPR ");
2302 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2306 /* Binary arithmetic and logic expressions. */
2307 case WIDEN_SUM_EXPR
:
2308 case WIDEN_MULT_EXPR
:
2310 case MULT_HIGHPART_EXPR
:
2312 case POINTER_PLUS_EXPR
:
2313 case POINTER_DIFF_EXPR
:
2315 case TRUNC_DIV_EXPR
:
2317 case FLOOR_DIV_EXPR
:
2318 case ROUND_DIV_EXPR
:
2319 case TRUNC_MOD_EXPR
:
2321 case FLOOR_MOD_EXPR
:
2322 case ROUND_MOD_EXPR
:
2324 case EXACT_DIV_EXPR
:
2329 case WIDEN_LSHIFT_EXPR
:
2333 case TRUTH_ANDIF_EXPR
:
2334 case TRUTH_ORIF_EXPR
:
2335 case TRUTH_AND_EXPR
:
2337 case TRUTH_XOR_EXPR
:
2351 case UNORDERED_EXPR
:
2353 const char *op
= op_symbol (node
);
2354 op0
= TREE_OPERAND (node
, 0);
2355 op1
= TREE_OPERAND (node
, 1);
2357 /* When the operands are expressions with less priority,
2358 keep semantics of the tree representation. */
2359 if (op_prio (op0
) <= op_prio (node
))
2362 dump_generic_node (pp
, op0
, spc
, flags
, false);
2363 pp_right_paren (pp
);
2366 dump_generic_node (pp
, op0
, spc
, flags
, false);
2372 /* When the operands are expressions with less priority,
2373 keep semantics of the tree representation. */
2374 if (op_prio (op1
) <= op_prio (node
))
2377 dump_generic_node (pp
, op1
, spc
, flags
, false);
2378 pp_right_paren (pp
);
2381 dump_generic_node (pp
, op1
, spc
, flags
, false);
2385 /* Unary arithmetic and logic expressions. */
2388 case TRUTH_NOT_EXPR
:
2390 case PREDECREMENT_EXPR
:
2391 case PREINCREMENT_EXPR
:
2393 if (TREE_CODE (node
) == ADDR_EXPR
2394 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
2395 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
2396 ; /* Do not output '&' for strings and function pointers. */
2398 pp_string (pp
, op_symbol (node
));
2400 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2403 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2404 pp_right_paren (pp
);
2407 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2410 case POSTDECREMENT_EXPR
:
2411 case POSTINCREMENT_EXPR
:
2412 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
2415 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2416 pp_right_paren (pp
);
2419 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2420 pp_string (pp
, op_symbol (node
));
2424 pp_string (pp
, "MIN_EXPR <");
2425 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2426 pp_string (pp
, ", ");
2427 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2432 pp_string (pp
, "MAX_EXPR <");
2433 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2434 pp_string (pp
, ", ");
2435 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2440 pp_string (pp
, "ABS_EXPR <");
2441 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2449 case ADDR_SPACE_CONVERT_EXPR
:
2450 case FIXED_CONVERT_EXPR
:
2451 case FIX_TRUNC_EXPR
:
2454 type
= TREE_TYPE (node
);
2455 op0
= TREE_OPERAND (node
, 0);
2456 if (type
!= TREE_TYPE (op0
))
2459 dump_generic_node (pp
, type
, spc
, flags
, false);
2460 pp_string (pp
, ") ");
2462 if (op_prio (op0
) < op_prio (node
))
2464 dump_generic_node (pp
, op0
, spc
, flags
, false);
2465 if (op_prio (op0
) < op_prio (node
))
2466 pp_right_paren (pp
);
2469 case VIEW_CONVERT_EXPR
:
2470 pp_string (pp
, "VIEW_CONVERT_EXPR<");
2471 dump_generic_node (pp
, TREE_TYPE (node
), spc
, flags
, false);
2472 pp_string (pp
, ">(");
2473 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2474 pp_right_paren (pp
);
2478 pp_string (pp
, "((");
2479 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2480 pp_string (pp
, "))");
2483 case NON_LVALUE_EXPR
:
2484 pp_string (pp
, "NON_LVALUE_EXPR <");
2485 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2490 pp_string (pp
, "SAVE_EXPR <");
2491 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2496 pp_string (pp
, "COMPLEX_EXPR <");
2497 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2498 pp_string (pp
, ", ");
2499 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2504 pp_string (pp
, "CONJ_EXPR <");
2505 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2510 if (flags
& TDF_GIMPLE
)
2512 pp_string (pp
, "__real ");
2513 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2517 pp_string (pp
, "REALPART_EXPR <");
2518 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2524 if (flags
& TDF_GIMPLE
)
2526 pp_string (pp
, "__imag ");
2527 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2531 pp_string (pp
, "IMAGPART_EXPR <");
2532 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2538 pp_string (pp
, "VA_ARG_EXPR <");
2539 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2543 case TRY_FINALLY_EXPR
:
2544 case TRY_CATCH_EXPR
:
2545 pp_string (pp
, "try");
2546 newline_and_indent (pp
, spc
+2);
2548 newline_and_indent (pp
, spc
+4);
2549 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2550 newline_and_indent (pp
, spc
+2);
2551 pp_right_brace (pp
);
2552 newline_and_indent (pp
, spc
);
2554 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2555 newline_and_indent (pp
, spc
+2);
2557 newline_and_indent (pp
, spc
+4);
2558 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2559 newline_and_indent (pp
, spc
+2);
2560 pp_right_brace (pp
);
2565 pp_string (pp
, "catch (");
2566 dump_generic_node (pp
, CATCH_TYPES (node
), spc
+2, flags
, false);
2567 pp_right_paren (pp
);
2568 newline_and_indent (pp
, spc
+2);
2570 newline_and_indent (pp
, spc
+4);
2571 dump_generic_node (pp
, CATCH_BODY (node
), spc
+4, flags
, true);
2572 newline_and_indent (pp
, spc
+2);
2573 pp_right_brace (pp
);
2577 case EH_FILTER_EXPR
:
2578 pp_string (pp
, "<<<eh_filter (");
2579 dump_generic_node (pp
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2580 pp_string (pp
, ")>>>");
2581 newline_and_indent (pp
, spc
+2);
2583 newline_and_indent (pp
, spc
+4);
2584 dump_generic_node (pp
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2585 newline_and_indent (pp
, spc
+2);
2586 pp_right_brace (pp
);
2591 op0
= TREE_OPERAND (node
, 0);
2592 /* If this is for break or continue, don't bother printing it. */
2593 if (DECL_NAME (op0
))
2595 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2596 if (strcmp (name
, "break") == 0
2597 || strcmp (name
, "continue") == 0)
2600 dump_generic_node (pp
, op0
, spc
, flags
, false);
2602 if (DECL_NONLOCAL (op0
))
2603 pp_string (pp
, " [non-local]");
2607 pp_string (pp
, "while (1)");
2608 if (!(flags
& TDF_SLIM
))
2610 newline_and_indent (pp
, spc
+2);
2612 newline_and_indent (pp
, spc
+4);
2613 dump_generic_node (pp
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2614 newline_and_indent (pp
, spc
+2);
2615 pp_right_brace (pp
);
2621 pp_string (pp
, "// predicted ");
2622 if (PREDICT_EXPR_OUTCOME (node
))
2623 pp_string (pp
, "likely by ");
2625 pp_string (pp
, "unlikely by ");
2626 pp_string (pp
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2627 pp_string (pp
, " predictor.");
2631 pp_string (pp
, "ANNOTATE_EXPR <");
2632 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2633 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2635 case annot_expr_ivdep_kind
:
2636 pp_string (pp
, ", ivdep");
2638 case annot_expr_unroll_kind
:
2639 pp_printf (pp
, ", unroll %d",
2640 (int) TREE_INT_CST_LOW (TREE_OPERAND (node
, 2)));
2642 case annot_expr_no_vector_kind
:
2643 pp_string (pp
, ", no-vector");
2645 case annot_expr_vector_kind
:
2646 pp_string (pp
, ", vector");
2648 case annot_expr_parallel_kind
:
2649 pp_string (pp
, ", parallel");
2658 pp_string (pp
, "return");
2659 op0
= TREE_OPERAND (node
, 0);
2663 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2664 dump_generic_node (pp
, TREE_OPERAND (op0
, 1),
2667 dump_generic_node (pp
, op0
, spc
, flags
, false);
2672 pp_string (pp
, "if (");
2673 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2674 pp_string (pp
, ") break");
2678 pp_string (pp
, "switch (");
2679 dump_generic_node (pp
, SWITCH_COND (node
), spc
, flags
, false);
2680 pp_right_paren (pp
);
2681 if (!(flags
& TDF_SLIM
))
2683 newline_and_indent (pp
, spc
+2);
2685 if (SWITCH_BODY (node
))
2687 newline_and_indent (pp
, spc
+4);
2688 dump_generic_node (pp
, SWITCH_BODY (node
), spc
+4, flags
,
2691 newline_and_indent (pp
, spc
+2);
2692 pp_right_brace (pp
);
2698 op0
= GOTO_DESTINATION (node
);
2699 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2701 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2702 if (strcmp (name
, "break") == 0
2703 || strcmp (name
, "continue") == 0)
2705 pp_string (pp
, name
);
2709 pp_string (pp
, "goto ");
2710 dump_generic_node (pp
, op0
, spc
, flags
, false);
2714 pp_string (pp
, "__asm__");
2715 if (ASM_VOLATILE_P (node
))
2716 pp_string (pp
, " __volatile__");
2718 dump_generic_node (pp
, ASM_STRING (node
), spc
, flags
, false);
2720 dump_generic_node (pp
, ASM_OUTPUTS (node
), spc
, flags
, false);
2722 dump_generic_node (pp
, ASM_INPUTS (node
), spc
, flags
, false);
2723 if (ASM_CLOBBERS (node
))
2726 dump_generic_node (pp
, ASM_CLOBBERS (node
), spc
, flags
, false);
2728 pp_right_paren (pp
);
2731 case CASE_LABEL_EXPR
:
2732 if (CASE_LOW (node
) && CASE_HIGH (node
))
2734 pp_string (pp
, "case ");
2735 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2736 pp_string (pp
, " ... ");
2737 dump_generic_node (pp
, CASE_HIGH (node
), spc
, flags
, false);
2739 else if (CASE_LOW (node
))
2741 pp_string (pp
, "case ");
2742 dump_generic_node (pp
, CASE_LOW (node
), spc
, flags
, false);
2745 pp_string (pp
, "default");
2750 pp_string (pp
, "OBJ_TYPE_REF(");
2751 dump_generic_node (pp
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2753 /* We omit the class type for -fcompare-debug because we may
2754 drop TYPE_BINFO early depending on debug info, and then
2755 virtual_method_call_p would return false, whereas when
2756 TYPE_BINFO is preserved it may still return true and then
2757 we'd print the class type. Compare tree and rtl dumps for
2758 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
2759 for example, at occurrences of OBJ_TYPE_REF. */
2760 if (!(flags
& (TDF_SLIM
| TDF_COMPARE_DEBUG
))
2761 && virtual_method_call_p (node
))
2763 pp_string (pp
, "(");
2764 dump_generic_node (pp
, obj_type_ref_class (node
), spc
, flags
, false);
2765 pp_string (pp
, ")");
2767 dump_generic_node (pp
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2769 dump_generic_node (pp
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2770 pp_right_paren (pp
);
2774 if (SSA_NAME_IDENTIFIER (node
))
2776 if ((flags
& TDF_NOUID
)
2777 && SSA_NAME_VAR (node
)
2778 && DECL_NAMELESS (SSA_NAME_VAR (node
)))
2779 dump_fancy_name (pp
, SSA_NAME_IDENTIFIER (node
));
2780 else if (! (flags
& TDF_GIMPLE
)
2781 || SSA_NAME_VAR (node
))
2782 dump_generic_node (pp
, SSA_NAME_IDENTIFIER (node
),
2786 pp_decimal_int (pp
, SSA_NAME_VERSION (node
));
2787 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2788 pp_string (pp
, "(D)");
2789 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2790 pp_string (pp
, "(ab)");
2793 case WITH_SIZE_EXPR
:
2794 pp_string (pp
, "WITH_SIZE_EXPR <");
2795 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2796 pp_string (pp
, ", ");
2797 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2802 pp_string (pp
, "ASSERT_EXPR <");
2803 dump_generic_node (pp
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2804 pp_string (pp
, ", ");
2805 dump_generic_node (pp
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2810 pp_string (pp
, "scev_known");
2813 case SCEV_NOT_KNOWN
:
2814 pp_string (pp
, "scev_not_known");
2817 case POLYNOMIAL_CHREC
:
2819 dump_generic_node (pp
, CHREC_LEFT (node
), spc
, flags
, false);
2820 pp_string (pp
, ", +, ");
2821 dump_generic_node (pp
, CHREC_RIGHT (node
), spc
, flags
, false);
2822 pp_printf (pp
, "}_%u", CHREC_VARIABLE (node
));
2826 case REALIGN_LOAD_EXPR
:
2827 pp_string (pp
, "REALIGN_LOAD <");
2828 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2829 pp_string (pp
, ", ");
2830 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2831 pp_string (pp
, ", ");
2832 dump_generic_node (pp
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2837 pp_string (pp
, " VEC_COND_EXPR < ");
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);
2843 pp_string (pp
, " > ");
2847 pp_string (pp
, " VEC_PERM_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
, " DOT_PROD_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
, " > ");
2866 case WIDEN_MULT_PLUS_EXPR
:
2867 pp_string (pp
, " WIDEN_MULT_PLUS_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_MINUS_EXPR
:
2877 pp_string (pp
, " WIDEN_MULT_MINUS_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
, " > ");
2887 pp_string (pp
, " FMA_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
, "#pragma acc parallel");
2898 goto dump_omp_clauses_body
;
2901 pp_string (pp
, "#pragma acc kernels");
2902 goto dump_omp_clauses_body
;
2905 pp_string (pp
, "#pragma acc data");
2906 dump_omp_clauses (pp
, OACC_DATA_CLAUSES (node
), spc
, flags
);
2909 case OACC_HOST_DATA
:
2910 pp_string (pp
, "#pragma acc host_data");
2911 dump_omp_clauses (pp
, OACC_HOST_DATA_CLAUSES (node
), spc
, flags
);
2915 pp_string (pp
, "#pragma acc declare");
2916 dump_omp_clauses (pp
, OACC_DECLARE_CLAUSES (node
), spc
, flags
);
2920 pp_string (pp
, "#pragma acc update");
2921 dump_omp_clauses (pp
, OACC_UPDATE_CLAUSES (node
), spc
, flags
);
2924 case OACC_ENTER_DATA
:
2925 pp_string (pp
, "#pragma acc enter data");
2926 dump_omp_clauses (pp
, OACC_ENTER_DATA_CLAUSES (node
), spc
, flags
);
2929 case OACC_EXIT_DATA
:
2930 pp_string (pp
, "#pragma acc exit data");
2931 dump_omp_clauses (pp
, OACC_EXIT_DATA_CLAUSES (node
), spc
, flags
);
2935 pp_string (pp
, "#pragma acc cache");
2936 dump_omp_clauses (pp
, OACC_CACHE_CLAUSES (node
), spc
, flags
);
2940 pp_string (pp
, "#pragma omp parallel");
2941 dump_omp_clauses (pp
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2944 dump_omp_clauses_body
:
2945 dump_omp_clauses (pp
, OMP_CLAUSES (node
), spc
, flags
);
2949 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2951 newline_and_indent (pp
, spc
+ 2);
2953 newline_and_indent (pp
, spc
+ 4);
2954 dump_generic_node (pp
, OMP_BODY (node
), spc
+ 4, flags
, false);
2955 newline_and_indent (pp
, spc
+ 2);
2956 pp_right_brace (pp
);
2962 pp_string (pp
, "#pragma omp task");
2963 dump_omp_clauses (pp
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2967 pp_string (pp
, "#pragma omp for");
2971 pp_string (pp
, "#pragma omp simd");
2974 case OMP_DISTRIBUTE
:
2975 pp_string (pp
, "#pragma omp distribute");
2979 pp_string (pp
, "#pragma omp taskloop");
2983 pp_string (pp
, "#pragma acc loop");
2987 pp_string (pp
, "#pragma omp teams");
2988 dump_omp_clauses (pp
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
2991 case OMP_TARGET_DATA
:
2992 pp_string (pp
, "#pragma omp target data");
2993 dump_omp_clauses (pp
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
2996 case OMP_TARGET_ENTER_DATA
:
2997 pp_string (pp
, "#pragma omp target enter data");
2998 dump_omp_clauses (pp
, OMP_TARGET_ENTER_DATA_CLAUSES (node
), spc
, flags
);
3002 case OMP_TARGET_EXIT_DATA
:
3003 pp_string (pp
, "#pragma omp target exit data");
3004 dump_omp_clauses (pp
, OMP_TARGET_EXIT_DATA_CLAUSES (node
), spc
, flags
);
3009 pp_string (pp
, "#pragma omp target");
3010 dump_omp_clauses (pp
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
3013 case OMP_TARGET_UPDATE
:
3014 pp_string (pp
, "#pragma omp target update");
3015 dump_omp_clauses (pp
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
3020 dump_omp_clauses (pp
, OMP_FOR_CLAUSES (node
), spc
, flags
);
3021 if (!(flags
& TDF_SLIM
))
3025 if (OMP_FOR_PRE_BODY (node
))
3027 newline_and_indent (pp
, spc
+ 2);
3030 newline_and_indent (pp
, spc
);
3031 dump_generic_node (pp
, OMP_FOR_PRE_BODY (node
),
3034 if (OMP_FOR_INIT (node
))
3037 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
3040 newline_and_indent (pp
, spc
);
3041 pp_string (pp
, "for (");
3042 dump_generic_node (pp
,
3043 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
3045 pp_string (pp
, "; ");
3046 dump_generic_node (pp
,
3047 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
3049 pp_string (pp
, "; ");
3050 dump_generic_node (pp
,
3051 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
3053 pp_right_paren (pp
);
3056 if (OMP_FOR_BODY (node
))
3058 newline_and_indent (pp
, spc
+ 2);
3060 newline_and_indent (pp
, spc
+ 4);
3061 dump_generic_node (pp
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
3063 newline_and_indent (pp
, spc
+ 2);
3064 pp_right_brace (pp
);
3066 if (OMP_FOR_INIT (node
))
3067 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
3068 if (OMP_FOR_PRE_BODY (node
))
3071 newline_and_indent (pp
, spc
+ 2);
3072 pp_right_brace (pp
);
3079 pp_string (pp
, "#pragma omp sections");
3080 dump_omp_clauses (pp
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
3084 pp_string (pp
, "#pragma omp section");
3088 pp_string (pp
, "#pragma omp master");
3092 pp_string (pp
, "#pragma omp taskgroup");
3096 pp_string (pp
, "#pragma omp ordered");
3097 dump_omp_clauses (pp
, OMP_ORDERED_CLAUSES (node
), spc
, flags
);
3101 pp_string (pp
, "#pragma omp critical");
3102 if (OMP_CRITICAL_NAME (node
))
3106 dump_generic_node (pp
, OMP_CRITICAL_NAME (node
), spc
,
3108 pp_right_paren (pp
);
3110 dump_omp_clauses (pp
, OMP_CRITICAL_CLAUSES (node
), spc
, flags
);
3114 pp_string (pp
, "#pragma omp atomic");
3115 if (OMP_ATOMIC_SEQ_CST (node
))
3116 pp_string (pp
, " seq_cst");
3117 newline_and_indent (pp
, spc
+ 2);
3118 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3122 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3125 case OMP_ATOMIC_READ
:
3126 pp_string (pp
, "#pragma omp atomic read");
3127 if (OMP_ATOMIC_SEQ_CST (node
))
3128 pp_string (pp
, " seq_cst");
3129 newline_and_indent (pp
, spc
+ 2);
3130 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3134 case OMP_ATOMIC_CAPTURE_OLD
:
3135 case OMP_ATOMIC_CAPTURE_NEW
:
3136 pp_string (pp
, "#pragma omp atomic capture");
3137 if (OMP_ATOMIC_SEQ_CST (node
))
3138 pp_string (pp
, " seq_cst");
3139 newline_and_indent (pp
, spc
+ 2);
3140 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3144 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3148 pp_string (pp
, "#pragma omp single");
3149 dump_omp_clauses (pp
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
3153 dump_omp_clause (pp
, node
, spc
, flags
);
3157 case TRANSACTION_EXPR
:
3158 if (TRANSACTION_EXPR_OUTER (node
))
3159 pp_string (pp
, "__transaction_atomic [[outer]]");
3160 else if (TRANSACTION_EXPR_RELAXED (node
))
3161 pp_string (pp
, "__transaction_relaxed");
3163 pp_string (pp
, "__transaction_atomic");
3164 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
3166 newline_and_indent (pp
, spc
);
3168 newline_and_indent (pp
, spc
+ 2);
3169 dump_generic_node (pp
, TRANSACTION_EXPR_BODY (node
),
3170 spc
+ 2, flags
, false);
3171 newline_and_indent (pp
, spc
);
3172 pp_right_brace (pp
);
3177 case VEC_SERIES_EXPR
:
3178 case VEC_WIDEN_MULT_HI_EXPR
:
3179 case VEC_WIDEN_MULT_LO_EXPR
:
3180 case VEC_WIDEN_MULT_EVEN_EXPR
:
3181 case VEC_WIDEN_MULT_ODD_EXPR
:
3182 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3183 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3185 for (str
= get_tree_code_name (code
); *str
; str
++)
3186 pp_character (pp
, TOUPPER (*str
));
3187 pp_string (pp
, " < ");
3188 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3189 pp_string (pp
, ", ");
3190 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3191 pp_string (pp
, " > ");
3194 case VEC_DUPLICATE_EXPR
:
3196 for (str
= get_tree_code_name (code
); *str
; str
++)
3197 pp_character (pp
, TOUPPER (*str
));
3198 pp_string (pp
, " < ");
3199 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3200 pp_string (pp
, " > ");
3203 case VEC_UNPACK_HI_EXPR
:
3204 pp_string (pp
, " VEC_UNPACK_HI_EXPR < ");
3205 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3206 pp_string (pp
, " > ");
3209 case VEC_UNPACK_LO_EXPR
:
3210 pp_string (pp
, " VEC_UNPACK_LO_EXPR < ");
3211 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3212 pp_string (pp
, " > ");
3215 case VEC_UNPACK_FLOAT_HI_EXPR
:
3216 pp_string (pp
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3217 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3218 pp_string (pp
, " > ");
3221 case VEC_UNPACK_FLOAT_LO_EXPR
:
3222 pp_string (pp
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3223 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3224 pp_string (pp
, " > ");
3227 case VEC_PACK_TRUNC_EXPR
:
3228 pp_string (pp
, " VEC_PACK_TRUNC_EXPR < ");
3229 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3230 pp_string (pp
, ", ");
3231 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3232 pp_string (pp
, " > ");
3235 case VEC_PACK_SAT_EXPR
:
3236 pp_string (pp
, " VEC_PACK_SAT_EXPR < ");
3237 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3238 pp_string (pp
, ", ");
3239 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3240 pp_string (pp
, " > ");
3243 case VEC_PACK_FIX_TRUNC_EXPR
:
3244 pp_string (pp
, " VEC_PACK_FIX_TRUNC_EXPR < ");
3245 dump_generic_node (pp
, TREE_OPERAND (node
, 0), spc
, flags
, false);
3246 pp_string (pp
, ", ");
3247 dump_generic_node (pp
, TREE_OPERAND (node
, 1), spc
, flags
, false);
3248 pp_string (pp
, " > ");
3252 dump_block_node (pp
, node
, spc
, flags
);
3255 case DEBUG_BEGIN_STMT
:
3256 pp_string (pp
, "# DEBUG BEGIN STMT");
3263 if (is_stmt
&& is_expr
)
3269 /* Print the declaration of a variable. */
3272 print_declaration (pretty_printer
*pp
, tree t
, int spc
, dump_flags_t flags
)
3276 if (TREE_CODE(t
) == NAMELIST_DECL
)
3278 pp_string(pp
, "namelist ");
3279 dump_decl_name (pp
, t
, flags
);
3284 if (TREE_CODE (t
) == TYPE_DECL
)
3285 pp_string (pp
, "typedef ");
3287 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
3288 pp_string (pp
, "register ");
3290 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
3291 pp_string (pp
, "extern ");
3292 else if (TREE_STATIC (t
))
3293 pp_string (pp
, "static ");
3295 /* Print the type and name. */
3296 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3300 /* Print array's type. */
3301 tmp
= TREE_TYPE (t
);
3302 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
3303 tmp
= TREE_TYPE (tmp
);
3304 dump_generic_node (pp
, TREE_TYPE (tmp
), spc
, flags
, false);
3306 /* Print variable's name. */
3308 dump_generic_node (pp
, t
, spc
, flags
, false);
3310 /* Print the dimensions. */
3311 tmp
= TREE_TYPE (t
);
3312 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
3314 dump_array_domain (pp
, TYPE_DOMAIN (tmp
), spc
, flags
);
3315 tmp
= TREE_TYPE (tmp
);
3318 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3320 dump_generic_node (pp
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
3322 dump_decl_name (pp
, t
, flags
);
3323 dump_function_declaration (pp
, TREE_TYPE (t
), spc
, flags
);
3327 /* Print type declaration. */
3328 dump_generic_node (pp
, TREE_TYPE (t
), spc
, flags
, false);
3330 /* Print variable's name. */
3332 dump_generic_node (pp
, t
, spc
, flags
, false);
3335 if (VAR_P (t
) && DECL_HARD_REGISTER (t
))
3337 pp_string (pp
, " __asm__ ");
3339 dump_generic_node (pp
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
3340 pp_right_paren (pp
);
3343 /* The initial value of a function serves to determine whether the function
3344 is declared or defined. So the following does not apply to function
3346 if (TREE_CODE (t
) != FUNCTION_DECL
)
3348 /* Print the initial value. */
3349 if (DECL_INITIAL (t
))
3354 if (!(flags
& TDF_SLIM
))
3355 dump_generic_node (pp
, DECL_INITIAL (t
), spc
, flags
, false);
3357 pp_string (pp
, "<<< omitted >>>");
3361 if (VAR_P (t
) && DECL_HAS_VALUE_EXPR_P (t
))
3363 pp_string (pp
, " [value-expr: ");
3364 dump_generic_node (pp
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
3365 pp_right_bracket (pp
);
3372 /* Prints a structure: name, fields, and methods.
3373 FIXME: Still incomplete. */
3376 print_struct_decl (pretty_printer
*pp
, const_tree node
, int spc
,
3379 /* Print the name of the structure. */
3380 if (TYPE_NAME (node
))
3383 if (TREE_CODE (node
) == RECORD_TYPE
)
3384 pp_string (pp
, "struct ");
3385 else if ((TREE_CODE (node
) == UNION_TYPE
3386 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
3387 pp_string (pp
, "union ");
3389 dump_generic_node (pp
, TYPE_NAME (node
), spc
, 0, false);
3392 /* Print the contents of the structure. */
3398 /* Print the fields of the structure. */
3401 tmp
= TYPE_FIELDS (node
);
3404 /* Avoid to print recursively the structure. */
3405 /* FIXME : Not implemented correctly...,
3406 what about the case when we have a cycle in the contain graph? ...
3407 Maybe this could be solved by looking at the scope in which the
3408 structure was declared. */
3409 if (TREE_TYPE (tmp
) != node
3410 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
3411 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
3413 print_declaration (pp
, tmp
, spc
+2, flags
);
3416 tmp
= DECL_CHAIN (tmp
);
3420 pp_right_brace (pp
);
3423 /* Return the priority of the operator CODE.
3425 From lowest to highest precedence with either left-to-right (L-R)
3426 or right-to-left (R-L) associativity]:
3429 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3441 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3442 15 [L-R] fn() [] -> .
3444 unary +, - and * have higher precedence than the corresponding binary
3448 op_code_prio (enum tree_code code
)
3465 case TRUTH_ORIF_EXPR
:
3468 case TRUTH_AND_EXPR
:
3469 case TRUTH_ANDIF_EXPR
:
3476 case TRUTH_XOR_EXPR
:
3493 case UNORDERED_EXPR
:
3504 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3505 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3506 case WIDEN_LSHIFT_EXPR
:
3509 case WIDEN_SUM_EXPR
:
3511 case POINTER_PLUS_EXPR
:
3512 case POINTER_DIFF_EXPR
:
3516 case VEC_WIDEN_MULT_HI_EXPR
:
3517 case VEC_WIDEN_MULT_LO_EXPR
:
3518 case WIDEN_MULT_EXPR
:
3520 case WIDEN_MULT_PLUS_EXPR
:
3521 case WIDEN_MULT_MINUS_EXPR
:
3523 case MULT_HIGHPART_EXPR
:
3524 case TRUNC_DIV_EXPR
:
3526 case FLOOR_DIV_EXPR
:
3527 case ROUND_DIV_EXPR
:
3529 case EXACT_DIV_EXPR
:
3530 case TRUNC_MOD_EXPR
:
3532 case FLOOR_MOD_EXPR
:
3533 case ROUND_MOD_EXPR
:
3537 case TRUTH_NOT_EXPR
:
3539 case POSTINCREMENT_EXPR
:
3540 case POSTDECREMENT_EXPR
:
3541 case PREINCREMENT_EXPR
:
3542 case PREDECREMENT_EXPR
:
3548 case FIX_TRUNC_EXPR
:
3554 case ARRAY_RANGE_REF
:
3558 /* Special expressions. */
3564 case VEC_UNPACK_HI_EXPR
:
3565 case VEC_UNPACK_LO_EXPR
:
3566 case VEC_UNPACK_FLOAT_HI_EXPR
:
3567 case VEC_UNPACK_FLOAT_LO_EXPR
:
3568 case VEC_PACK_TRUNC_EXPR
:
3569 case VEC_PACK_SAT_EXPR
:
3573 /* Return an arbitrarily high precedence to avoid surrounding single
3574 VAR_DECLs in ()s. */
3579 /* Return the priority of the operator OP. */
3582 op_prio (const_tree op
)
3584 enum tree_code code
;
3589 code
= TREE_CODE (op
);
3590 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3591 return op_prio (TREE_OPERAND (op
, 0));
3593 return op_code_prio (code
);
3596 /* Return the symbol associated with operator CODE. */
3599 op_symbol_code (enum tree_code code
)
3607 case TRUTH_ORIF_EXPR
:
3610 case TRUTH_AND_EXPR
:
3611 case TRUTH_ANDIF_EXPR
:
3617 case TRUTH_XOR_EXPR
:
3627 case UNORDERED_EXPR
:
3673 case WIDEN_LSHIFT_EXPR
:
3676 case POINTER_PLUS_EXPR
:
3682 case WIDEN_SUM_EXPR
:
3685 case WIDEN_MULT_EXPR
:
3688 case MULT_HIGHPART_EXPR
:
3693 case POINTER_DIFF_EXPR
:
3699 case TRUTH_NOT_EXPR
:
3706 case TRUNC_DIV_EXPR
:
3713 case FLOOR_DIV_EXPR
:
3716 case ROUND_DIV_EXPR
:
3719 case EXACT_DIV_EXPR
:
3722 case TRUNC_MOD_EXPR
:
3728 case FLOOR_MOD_EXPR
:
3731 case ROUND_MOD_EXPR
:
3734 case PREDECREMENT_EXPR
:
3737 case PREINCREMENT_EXPR
:
3740 case POSTDECREMENT_EXPR
:
3743 case POSTINCREMENT_EXPR
:
3753 return "<<< ??? >>>";
3757 /* Return the symbol associated with operator OP. */
3760 op_symbol (const_tree op
)
3762 return op_symbol_code (TREE_CODE (op
));
3765 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3766 the gimple_call_fn of a GIMPLE_CALL. */
3769 print_call_name (pretty_printer
*pp
, tree node
, dump_flags_t flags
)
3773 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3774 op0
= TREE_OPERAND (op0
, 0);
3777 switch (TREE_CODE (op0
))
3782 dump_function_name (pp
, op0
, flags
);
3788 op0
= TREE_OPERAND (op0
, 0);
3793 dump_generic_node (pp
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3794 pp_string (pp
, ") ? ");
3795 dump_generic_node (pp
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3796 pp_string (pp
, " : ");
3797 dump_generic_node (pp
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3801 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3802 dump_function_name (pp
, TREE_OPERAND (op0
, 0), flags
);
3804 dump_generic_node (pp
, op0
, 0, flags
, false);
3808 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3810 op0
= TREE_OPERAND (op0
, 0);
3817 dump_generic_node (pp
, op0
, 0, flags
, false);
3825 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3828 pretty_print_string (pretty_printer
*pp
, const char *str
)
3838 pp_string (pp
, "\\b");
3842 pp_string (pp
, "\\f");
3846 pp_string (pp
, "\\n");
3850 pp_string (pp
, "\\r");
3854 pp_string (pp
, "\\t");
3858 pp_string (pp
, "\\v");
3862 pp_string (pp
, "\\\\");
3866 pp_string (pp
, "\\\"");
3870 pp_string (pp
, "\\'");
3873 /* No need to handle \0; the loop terminates on \0. */
3876 pp_string (pp
, "\\1");
3880 pp_string (pp
, "\\2");
3884 pp_string (pp
, "\\3");
3888 pp_string (pp
, "\\4");
3892 pp_string (pp
, "\\5");
3896 pp_string (pp
, "\\6");
3900 pp_string (pp
, "\\7");
3904 if (!ISPRINT (str
[0]))
3907 sprintf (buf
, "\\x%x", (unsigned char)str
[0]);
3908 pp_string (pp
, buf
);
3911 pp_character (pp
, str
[0]);
3919 maybe_init_pretty_print (FILE *file
)
3923 tree_pp
= new pretty_printer ();
3924 pp_needs_newline (tree_pp
) = true;
3925 pp_translate_identifiers (tree_pp
) = false;
3928 tree_pp
->buffer
->stream
= file
;
3932 newline_and_indent (pretty_printer
*pp
, int spc
)
3938 /* Handle the %K format for TEXT. Separate from default_tree_printer
3939 so it can also be used in front ends.
3940 Argument is a statement from which EXPR_LOCATION and TREE_BLOCK will
3944 percent_K_format (text_info
*text
, tree t
)
3946 text
->set_location (0, EXPR_LOCATION (t
), true);
3947 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3948 tree block
= TREE_BLOCK (t
);
3949 *pp_ti_abstract_origin (text
) = NULL
;
3953 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3954 representing the outermost block of an inlined function.
3955 So walk the BLOCK tree until we hit such a scope. */
3957 && TREE_CODE (block
) == BLOCK
)
3959 if (inlined_function_outer_scope_p (block
))
3961 *pp_ti_abstract_origin (text
) = block
;
3964 block
= BLOCK_SUPERCONTEXT (block
);
3970 && TREE_CODE (block
) == BLOCK
3971 && BLOCK_ABSTRACT_ORIGIN (block
))
3973 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3975 while (TREE_CODE (ao
) == BLOCK
3976 && BLOCK_ABSTRACT_ORIGIN (ao
)
3977 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3978 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3980 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3982 *pp_ti_abstract_origin (text
) = block
;
3985 block
= BLOCK_SUPERCONTEXT (block
);
3989 /* Print the identifier ID to PRETTY-PRINTER. */
3992 pp_tree_identifier (pretty_printer
*pp
, tree id
)
3994 if (pp_translate_identifiers (pp
))
3996 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
3997 pp_append_text (pp
, text
, text
+ strlen (text
));
4000 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
4001 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
4004 /* A helper function that is used to dump function information before the
4008 dump_function_header (FILE *dump_file
, tree fdecl
, dump_flags_t flags
)
4010 const char *dname
, *aname
;
4011 struct cgraph_node
*node
= cgraph_node::get (fdecl
);
4012 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
4014 dname
= lang_hooks
.decl_printable_name (fdecl
, 1);
4016 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
4017 aname
= (IDENTIFIER_POINTER
4018 (DECL_ASSEMBLER_NAME (fdecl
)));
4020 aname
= "<unset-asm-name>";
4022 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
4023 dname
, aname
, fun
->funcdef_no
);
4024 if (!(flags
& TDF_NOUID
))
4025 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
4028 fprintf (dump_file
, ", cgraph_uid=%d", node
->uid
);
4029 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
4030 node
->frequency
== NODE_FREQUENCY_HOT
4032 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
4033 ? " (unlikely executed)"
4034 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
4035 ? " (executed once)"
4039 fprintf (dump_file
, ")\n\n");
4042 /* Dump double_int D to pretty_printer PP. UNS is true
4043 if D is unsigned and false otherwise. */
4045 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
4048 pp_wide_integer (pp
, d
.low
);
4049 else if (d
.fits_uhwi ())
4050 pp_unsigned_wide_integer (pp
, d
.low
);
4053 unsigned HOST_WIDE_INT low
= d
.low
;
4054 HOST_WIDE_INT high
= d
.high
;
4055 if (!uns
&& d
.is_negative ())
4058 high
= ~high
+ !low
;
4061 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4063 sprintf (pp_buffer (pp
)->digit_buffer
,
4064 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4065 (unsigned HOST_WIDE_INT
) high
, low
);
4066 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);