1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2013 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"
26 #include "stor-layout.h"
28 #include "tree-pretty-print.h"
32 #include "langhooks.h"
33 #include "tree-iterator.h"
34 #include "tree-chrec.h"
36 #include "value-prof.h"
38 #include "wide-int-print.h"
40 #include <new> // For placement-new.
42 /* Local functions, macros and variables. */
43 static const char *op_symbol (const_tree
);
44 static void pretty_print_string (pretty_printer
*, const char*);
45 static void newline_and_indent (pretty_printer
*, int);
46 static void maybe_init_pretty_print (FILE *);
47 static void print_struct_decl (pretty_printer
*, const_tree
, int, int);
48 static void do_niy (pretty_printer
*, const_tree
);
50 #define INDENT(SPACE) do { \
51 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
53 #define NIY do_niy (buffer, node)
55 static pretty_printer buffer
;
56 static int initialized
= 0;
58 /* Try to print something for an unknown tree code. */
61 do_niy (pretty_printer
*buffer
, const_tree node
)
65 pp_string (buffer
, "<<< Unknown tree: ");
66 pp_string (buffer
, get_tree_code_name (TREE_CODE (node
)));
70 len
= TREE_OPERAND_LENGTH (node
);
71 for (i
= 0; i
< len
; ++i
)
73 newline_and_indent (buffer
, 2);
74 dump_generic_node (buffer
, TREE_OPERAND (node
, i
), 2, 0, false);
78 pp_string (buffer
, " >>>");
81 /* Debugging function to print out a generic expression. */
84 debug_generic_expr (tree t
)
86 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
87 fprintf (stderr
, "\n");
90 /* Debugging function to print out a generic statement. */
93 debug_generic_stmt (tree t
)
95 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
96 fprintf (stderr
, "\n");
99 /* Debugging function to print out a chain of trees . */
102 debug_tree_chain (tree t
)
104 struct pointer_set_t
*seen
= pointer_set_create ();
108 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
109 fprintf (stderr
, " ");
111 if (pointer_set_insert (seen
, t
))
113 fprintf (stderr
, "... [cycled back to ");
114 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
115 fprintf (stderr
, "]");
119 fprintf (stderr
, "\n");
121 pointer_set_destroy (seen
);
124 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
126 print_generic_decl (FILE *file
, tree decl
, int flags
)
128 maybe_init_pretty_print (file
);
129 print_declaration (&buffer
, decl
, 2, flags
);
130 pp_write_text_to_stream (&buffer
);
133 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
134 to show in the dump. See TDF_* in dumpfile.h. */
137 print_generic_stmt (FILE *file
, tree t
, int flags
)
139 maybe_init_pretty_print (file
);
140 dump_generic_node (&buffer
, t
, 0, flags
, true);
141 pp_newline_and_flush (&buffer
);
144 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
145 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
149 print_generic_stmt_indented (FILE *file
, tree t
, int flags
, int indent
)
153 maybe_init_pretty_print (file
);
155 for (i
= 0; i
< indent
; i
++)
157 dump_generic_node (&buffer
, t
, indent
, flags
, true);
158 pp_newline_and_flush (&buffer
);
161 /* Print a single expression T on file FILE. FLAGS specifies details to show
162 in the dump. See TDF_* in dumpfile.h. */
165 print_generic_expr (FILE *file
, tree t
, int flags
)
167 maybe_init_pretty_print (file
);
168 dump_generic_node (&buffer
, t
, 0, flags
, false);
172 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
176 dump_decl_name (pretty_printer
*buffer
, tree node
, int flags
)
178 if (DECL_NAME (node
))
180 if ((flags
& TDF_ASMNAME
) && DECL_ASSEMBLER_NAME_SET_P (node
))
181 pp_tree_identifier (buffer
, DECL_ASSEMBLER_NAME (node
));
183 pp_tree_identifier (buffer
, DECL_NAME (node
));
185 if ((flags
& TDF_UID
) || DECL_NAME (node
) == NULL_TREE
)
187 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
188 pp_printf (buffer
, "L.%d", (int) LABEL_DECL_UID (node
));
189 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
191 if (flags
& TDF_NOUID
)
192 pp_string (buffer
, "D#xxxx");
194 pp_printf (buffer
, "D#%i", DEBUG_TEMP_UID (node
));
198 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
199 if (flags
& TDF_NOUID
)
200 pp_printf (buffer
, "%c.xxxx", c
);
202 pp_printf (buffer
, "%c.%u", c
, DECL_UID (node
));
205 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
207 if (flags
& TDF_NOUID
)
208 pp_printf (buffer
, "ptD.xxxx");
210 pp_printf (buffer
, "ptD.%u", DECL_PT_UID (node
));
214 /* Like the above, but used for pretty printing function calls. */
217 dump_function_name (pretty_printer
*buffer
, tree node
, int flags
)
219 if (TREE_CODE (node
) == NOP_EXPR
)
220 node
= TREE_OPERAND (node
, 0);
221 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
222 pp_string (buffer
, lang_hooks
.decl_printable_name (node
, 1));
224 dump_decl_name (buffer
, node
, flags
);
227 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
228 FLAGS are as in dump_generic_node. */
231 dump_function_declaration (pretty_printer
*buffer
, tree node
,
234 bool wrote_arg
= false;
238 pp_left_paren (buffer
);
240 /* Print the argument types. */
241 arg
= TYPE_ARG_TYPES (node
);
242 while (arg
&& arg
!= void_list_node
&& arg
!= error_mark_node
)
250 dump_generic_node (buffer
, TREE_VALUE (arg
), spc
, flags
, false);
251 arg
= TREE_CHAIN (arg
);
254 /* Drop the trailing void_type_node if we had any previous argument. */
255 if (arg
== void_list_node
&& !wrote_arg
)
256 pp_string (buffer
, "void");
257 /* Properly dump vararg function types. */
258 else if (!arg
&& wrote_arg
)
259 pp_string (buffer
, ", ...");
260 /* Avoid printing any arg for unprototyped functions. */
262 pp_right_paren (buffer
);
265 /* Dump the domain associated with an array. */
268 dump_array_domain (pretty_printer
*buffer
, tree domain
, int spc
, int flags
)
270 pp_left_bracket (buffer
);
273 tree min
= TYPE_MIN_VALUE (domain
);
274 tree max
= TYPE_MAX_VALUE (domain
);
277 && integer_zerop (min
)
278 && tree_fits_shwi_p (max
))
279 pp_wide_integer (buffer
, tree_to_shwi (max
) + 1);
283 dump_generic_node (buffer
, min
, spc
, flags
, false);
286 dump_generic_node (buffer
, max
, spc
, flags
, false);
290 pp_string (buffer
, "<unknown>");
291 pp_right_bracket (buffer
);
295 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
296 dump_generic_node. */
299 dump_omp_clause (pretty_printer
*buffer
, tree clause
, int spc
, int flags
)
303 switch (OMP_CLAUSE_CODE (clause
))
305 case OMP_CLAUSE_PRIVATE
:
308 case OMP_CLAUSE_SHARED
:
311 case OMP_CLAUSE_FIRSTPRIVATE
:
312 name
= "firstprivate";
314 case OMP_CLAUSE_LASTPRIVATE
:
315 name
= "lastprivate";
317 case OMP_CLAUSE_COPYIN
:
320 case OMP_CLAUSE_COPYPRIVATE
:
321 name
= "copyprivate";
323 case OMP_CLAUSE_UNIFORM
:
326 case OMP_CLAUSE__LOOPTEMP_
:
330 pp_string (buffer
, name
);
331 pp_left_paren (buffer
);
332 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
334 pp_right_paren (buffer
);
337 case OMP_CLAUSE_REDUCTION
:
338 pp_string (buffer
, "reduction(");
339 if (OMP_CLAUSE_REDUCTION_CODE (clause
) != ERROR_MARK
)
342 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
345 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
347 pp_right_paren (buffer
);
351 pp_string (buffer
, "if(");
352 dump_generic_node (buffer
, OMP_CLAUSE_IF_EXPR (clause
),
354 pp_right_paren (buffer
);
357 case OMP_CLAUSE_NUM_THREADS
:
358 pp_string (buffer
, "num_threads(");
359 dump_generic_node (buffer
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
361 pp_right_paren (buffer
);
364 case OMP_CLAUSE_NOWAIT
:
365 pp_string (buffer
, "nowait");
367 case OMP_CLAUSE_ORDERED
:
368 pp_string (buffer
, "ordered");
371 case OMP_CLAUSE_DEFAULT
:
372 pp_string (buffer
, "default(");
373 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
375 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
377 case OMP_CLAUSE_DEFAULT_SHARED
:
378 pp_string (buffer
, "shared");
380 case OMP_CLAUSE_DEFAULT_NONE
:
381 pp_string (buffer
, "none");
383 case OMP_CLAUSE_DEFAULT_PRIVATE
:
384 pp_string (buffer
, "private");
386 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
387 pp_string (buffer
, "firstprivate");
392 pp_right_paren (buffer
);
395 case OMP_CLAUSE_SCHEDULE
:
396 pp_string (buffer
, "schedule(");
397 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
))
399 case OMP_CLAUSE_SCHEDULE_STATIC
:
400 pp_string (buffer
, "static");
402 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
403 pp_string (buffer
, "dynamic");
405 case OMP_CLAUSE_SCHEDULE_GUIDED
:
406 pp_string (buffer
, "guided");
408 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
409 pp_string (buffer
, "runtime");
411 case OMP_CLAUSE_SCHEDULE_AUTO
:
412 pp_string (buffer
, "auto");
417 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
420 dump_generic_node (buffer
, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
423 pp_right_paren (buffer
);
426 case OMP_CLAUSE_UNTIED
:
427 pp_string (buffer
, "untied");
430 case OMP_CLAUSE_COLLAPSE
:
431 pp_string (buffer
, "collapse(");
432 dump_generic_node (buffer
, OMP_CLAUSE_COLLAPSE_EXPR (clause
),
434 pp_right_paren (buffer
);
437 case OMP_CLAUSE_FINAL
:
438 pp_string (buffer
, "final(");
439 dump_generic_node (buffer
, OMP_CLAUSE_FINAL_EXPR (clause
),
441 pp_right_paren (buffer
);
444 case OMP_CLAUSE_MERGEABLE
:
445 pp_string (buffer
, "mergeable");
448 case OMP_CLAUSE_LINEAR
:
449 pp_string (buffer
, "linear(");
450 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
453 dump_generic_node (buffer
, OMP_CLAUSE_LINEAR_STEP (clause
),
455 pp_right_paren (buffer
);
458 case OMP_CLAUSE_ALIGNED
:
459 pp_string (buffer
, "aligned(");
460 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
462 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
465 dump_generic_node (buffer
, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
),
468 pp_right_paren (buffer
);
471 case OMP_CLAUSE_DEPEND
:
472 pp_string (buffer
, "depend(");
473 switch (OMP_CLAUSE_DEPEND_KIND (clause
))
475 case OMP_CLAUSE_DEPEND_IN
:
476 pp_string (buffer
, "in");
478 case OMP_CLAUSE_DEPEND_OUT
:
479 pp_string (buffer
, "out");
481 case OMP_CLAUSE_DEPEND_INOUT
:
482 pp_string (buffer
, "inout");
488 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
490 pp_right_paren (buffer
);
494 pp_string (buffer
, "map(");
495 switch (OMP_CLAUSE_MAP_KIND (clause
))
497 case OMP_CLAUSE_MAP_ALLOC
:
498 case OMP_CLAUSE_MAP_POINTER
:
499 pp_string (buffer
, "alloc");
501 case OMP_CLAUSE_MAP_TO
:
502 pp_string (buffer
, "to");
504 case OMP_CLAUSE_MAP_FROM
:
505 pp_string (buffer
, "from");
507 case OMP_CLAUSE_MAP_TOFROM
:
508 pp_string (buffer
, "tofrom");
514 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
517 if (OMP_CLAUSE_SIZE (clause
))
519 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
520 && OMP_CLAUSE_MAP_KIND (clause
) == OMP_CLAUSE_MAP_POINTER
)
521 pp_string (buffer
, " [pointer assign, bias: ");
523 pp_string (buffer
, " [len: ");
524 dump_generic_node (buffer
, OMP_CLAUSE_SIZE (clause
),
526 pp_right_bracket (buffer
);
528 pp_right_paren (buffer
);
531 case OMP_CLAUSE_FROM
:
532 pp_string (buffer
, "from(");
533 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
535 goto print_clause_size
;
538 pp_string (buffer
, "to(");
539 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
541 goto print_clause_size
;
543 case OMP_CLAUSE_NUM_TEAMS
:
544 pp_string (buffer
, "num_teams(");
545 dump_generic_node (buffer
, OMP_CLAUSE_NUM_TEAMS_EXPR (clause
),
547 pp_right_paren (buffer
);
550 case OMP_CLAUSE_THREAD_LIMIT
:
551 pp_string (buffer
, "thread_limit(");
552 dump_generic_node (buffer
, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause
),
554 pp_right_paren (buffer
);
557 case OMP_CLAUSE_DEVICE
:
558 pp_string (buffer
, "device(");
559 dump_generic_node (buffer
, OMP_CLAUSE_DEVICE_ID (clause
),
561 pp_right_paren (buffer
);
564 case OMP_CLAUSE_DIST_SCHEDULE
:
565 pp_string (buffer
, "dist_schedule(static");
566 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
))
569 dump_generic_node (buffer
,
570 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
),
573 pp_right_paren (buffer
);
576 case OMP_CLAUSE_PROC_BIND
:
577 pp_string (buffer
, "proc_bind(");
578 switch (OMP_CLAUSE_PROC_BIND_KIND (clause
))
580 case OMP_CLAUSE_PROC_BIND_MASTER
:
581 pp_string (buffer
, "master");
583 case OMP_CLAUSE_PROC_BIND_CLOSE
:
584 pp_string (buffer
, "close");
586 case OMP_CLAUSE_PROC_BIND_SPREAD
:
587 pp_string (buffer
, "spread");
592 pp_right_paren (buffer
);
595 case OMP_CLAUSE_SAFELEN
:
596 pp_string (buffer
, "safelen(");
597 dump_generic_node (buffer
, OMP_CLAUSE_SAFELEN_EXPR (clause
),
599 pp_right_paren (buffer
);
602 case OMP_CLAUSE_SIMDLEN
:
603 pp_string (buffer
, "simdlen(");
604 dump_generic_node (buffer
, OMP_CLAUSE_SIMDLEN_EXPR (clause
),
606 pp_right_paren (buffer
);
609 case OMP_CLAUSE__SIMDUID_
:
610 pp_string (buffer
, "_simduid_(");
611 dump_generic_node (buffer
, OMP_CLAUSE__SIMDUID__DECL (clause
),
613 pp_right_paren (buffer
);
616 case OMP_CLAUSE_INBRANCH
:
617 pp_string (buffer
, "inbranch");
619 case OMP_CLAUSE_NOTINBRANCH
:
620 pp_string (buffer
, "notinbranch");
623 pp_string (buffer
, "for");
625 case OMP_CLAUSE_PARALLEL
:
626 pp_string (buffer
, "parallel");
628 case OMP_CLAUSE_SECTIONS
:
629 pp_string (buffer
, "sections");
631 case OMP_CLAUSE_TASKGROUP
:
632 pp_string (buffer
, "taskgroup");
636 /* Should never happen. */
637 dump_generic_node (buffer
, clause
, spc
, flags
, false);
643 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
644 dump_generic_node. */
647 dump_omp_clauses (pretty_printer
*buffer
, tree clause
, int spc
, int flags
)
655 dump_omp_clause (buffer
, clause
, spc
, flags
);
656 clause
= OMP_CLAUSE_CHAIN (clause
);
664 /* Dump location LOC to BUFFER. */
667 dump_location (pretty_printer
*buffer
, location_t loc
)
669 expanded_location xloc
= expand_location (loc
);
671 pp_left_bracket (buffer
);
674 pp_string (buffer
, xloc
.file
);
675 pp_string (buffer
, " : ");
677 pp_decimal_int (buffer
, xloc
.line
);
678 pp_string (buffer
, "] ");
682 /* Dump lexical block BLOCK. BUFFER, SPC and FLAGS are as in
683 dump_generic_node. */
686 dump_block_node (pretty_printer
*buffer
, tree block
, int spc
, int flags
)
690 pp_printf (buffer
, "BLOCK #%d ", BLOCK_NUMBER (block
));
692 if (flags
& TDF_ADDRESS
)
693 pp_printf (buffer
, "[%p] ", (void *) block
);
695 if (BLOCK_ABSTRACT (block
))
696 pp_string (buffer
, "[abstract] ");
698 if (TREE_ASM_WRITTEN (block
))
699 pp_string (buffer
, "[written] ");
701 if (flags
& TDF_SLIM
)
704 if (BLOCK_SOURCE_LOCATION (block
))
705 dump_location (buffer
, BLOCK_SOURCE_LOCATION (block
));
707 newline_and_indent (buffer
, spc
+ 2);
709 if (BLOCK_SUPERCONTEXT (block
))
711 pp_string (buffer
, "SUPERCONTEXT: ");
712 dump_generic_node (buffer
, BLOCK_SUPERCONTEXT (block
), 0,
713 flags
| TDF_SLIM
, false);
714 newline_and_indent (buffer
, spc
+ 2);
717 if (BLOCK_SUBBLOCKS (block
))
719 pp_string (buffer
, "SUBBLOCKS: ");
720 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
722 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
725 newline_and_indent (buffer
, spc
+ 2);
728 if (BLOCK_CHAIN (block
))
730 pp_string (buffer
, "SIBLINGS: ");
731 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
733 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
736 newline_and_indent (buffer
, spc
+ 2);
739 if (BLOCK_VARS (block
))
741 pp_string (buffer
, "VARS: ");
742 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
744 dump_generic_node (buffer
, t
, 0, flags
, false);
747 newline_and_indent (buffer
, spc
+ 2);
750 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block
)) > 0)
753 vec
<tree
, va_gc
> *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
755 pp_string (buffer
, "NONLOCALIZED_VARS: ");
756 FOR_EACH_VEC_ELT (*nlv
, i
, t
)
758 dump_generic_node (buffer
, t
, 0, flags
, false);
761 newline_and_indent (buffer
, spc
+ 2);
764 if (BLOCK_ABSTRACT_ORIGIN (block
))
766 pp_string (buffer
, "ABSTRACT_ORIGIN: ");
767 dump_generic_node (buffer
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
768 flags
| TDF_SLIM
, false);
769 newline_and_indent (buffer
, spc
+ 2);
772 if (BLOCK_FRAGMENT_ORIGIN (block
))
774 pp_string (buffer
, "FRAGMENT_ORIGIN: ");
775 dump_generic_node (buffer
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
776 flags
| TDF_SLIM
, false);
777 newline_and_indent (buffer
, spc
+ 2);
780 if (BLOCK_FRAGMENT_CHAIN (block
))
782 pp_string (buffer
, "FRAGMENT_CHAIN: ");
783 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
785 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
788 newline_and_indent (buffer
, spc
+ 2);
793 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
794 indent. FLAGS specifies details to show in the dump (see TDF_* in
795 dumpfile.h). If IS_STMT is true, the object printed is considered
796 to be a statement and it is terminated by ';' if appropriate. */
799 dump_generic_node (pretty_printer
*buffer
, tree node
, int spc
, int flags
,
808 if (node
== NULL_TREE
)
811 is_expr
= EXPR_P (node
);
813 if (is_stmt
&& (flags
& TDF_STMTADDR
))
814 pp_printf (buffer
, "<&%p> ", (void *)node
);
816 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
817 dump_location (buffer
, EXPR_LOCATION (node
));
819 code
= TREE_CODE (node
);
823 pp_string (buffer
, "<<< error >>>");
826 case IDENTIFIER_NODE
:
827 pp_tree_identifier (buffer
, node
);
831 while (node
&& node
!= error_mark_node
)
833 if (TREE_PURPOSE (node
))
835 dump_generic_node (buffer
, TREE_PURPOSE (node
), spc
, flags
, false);
838 dump_generic_node (buffer
, TREE_VALUE (node
), spc
, flags
, false);
839 node
= TREE_CHAIN (node
);
840 if (node
&& TREE_CODE (node
) == TREE_LIST
)
849 dump_generic_node (buffer
, BINFO_TYPE (node
), spc
, flags
, false);
855 if (TREE_VEC_LENGTH (node
) > 0)
857 size_t len
= TREE_VEC_LENGTH (node
);
858 for (i
= 0; i
< len
- 1; i
++)
860 dump_generic_node (buffer
, TREE_VEC_ELT (node
, i
), spc
, flags
,
865 dump_generic_node (buffer
, TREE_VEC_ELT (node
, len
- 1), spc
,
872 case POINTER_BOUNDS_TYPE
:
875 case FIXED_POINT_TYPE
:
881 unsigned int quals
= TYPE_QUALS (node
);
882 enum tree_code_class tclass
;
884 if (quals
& TYPE_QUAL_ATOMIC
)
885 pp_string (buffer
, "atomic ");
886 if (quals
& TYPE_QUAL_CONST
)
887 pp_string (buffer
, "const ");
888 else if (quals
& TYPE_QUAL_VOLATILE
)
889 pp_string (buffer
, "volatile ");
890 else if (quals
& TYPE_QUAL_RESTRICT
)
891 pp_string (buffer
, "restrict ");
893 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
895 pp_string (buffer
, "<address-space-");
896 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
897 pp_string (buffer
, "> ");
900 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
902 if (tclass
== tcc_declaration
)
904 if (DECL_NAME (node
))
905 dump_decl_name (buffer
, node
, flags
);
907 pp_string (buffer
, "<unnamed type decl>");
909 else if (tclass
== tcc_type
)
911 if (TYPE_NAME (node
))
913 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
914 pp_tree_identifier (buffer
, TYPE_NAME (node
));
915 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
916 && DECL_NAME (TYPE_NAME (node
)))
917 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
919 pp_string (buffer
, "<unnamed type>");
921 else if (TREE_CODE (node
) == VECTOR_TYPE
)
923 pp_string (buffer
, "vector");
924 pp_left_paren (buffer
);
925 pp_wide_integer (buffer
, TYPE_VECTOR_SUBPARTS (node
));
926 pp_string (buffer
, ") ");
927 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
929 else if (TREE_CODE (node
) == INTEGER_TYPE
)
931 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
932 pp_string (buffer
, (TYPE_UNSIGNED (node
)
935 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
936 pp_string (buffer
, (TYPE_UNSIGNED (node
)
939 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
940 pp_string (buffer
, (TYPE_UNSIGNED (node
)
943 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
944 pp_string (buffer
, (TYPE_UNSIGNED (node
)
947 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
948 pp_string (buffer
, (TYPE_UNSIGNED (node
)
949 ? "unsigned long long"
950 : "signed long long"));
951 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
952 && exact_log2 (TYPE_PRECISION (node
)) != -1)
954 pp_string (buffer
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
955 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
956 pp_string (buffer
, "_t");
960 pp_string (buffer
, (TYPE_UNSIGNED (node
)
961 ? "<unnamed-unsigned:"
962 : "<unnamed-signed:"));
963 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
967 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
969 pp_string (buffer
, "__complex__ ");
970 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
972 else if (TREE_CODE (node
) == REAL_TYPE
)
974 pp_string (buffer
, "<float:");
975 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
978 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
980 pp_string (buffer
, "<fixed-point-");
981 pp_string (buffer
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
982 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
985 else if (TREE_CODE (node
) == VOID_TYPE
)
986 pp_string (buffer
, "void");
988 pp_string (buffer
, "<unnamed type>");
995 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
997 if (TREE_TYPE (node
) == NULL
)
999 pp_string (buffer
, str
);
1000 pp_string (buffer
, "<null type>");
1002 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1004 tree fnode
= TREE_TYPE (node
);
1006 dump_generic_node (buffer
, TREE_TYPE (fnode
), spc
, flags
, false);
1008 pp_left_paren (buffer
);
1009 pp_string (buffer
, str
);
1010 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1011 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
1012 else if (flags
& TDF_NOUID
)
1013 pp_printf (buffer
, "<Txxxx>");
1015 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
1017 pp_right_paren (buffer
);
1018 dump_function_declaration (buffer
, fnode
, spc
, flags
);
1022 unsigned int quals
= TYPE_QUALS (node
);
1024 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1026 pp_string (buffer
, str
);
1028 if (quals
& TYPE_QUAL_CONST
)
1029 pp_string (buffer
, " const");
1030 if (quals
& TYPE_QUAL_VOLATILE
)
1031 pp_string (buffer
, " volatile");
1032 if (quals
& TYPE_QUAL_RESTRICT
)
1033 pp_string (buffer
, " restrict");
1035 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1037 pp_string (buffer
, " <address-space-");
1038 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
1039 pp_greater (buffer
);
1042 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1043 pp_string (buffer
, " {ref-all}");
1053 if (integer_zerop (TREE_OPERAND (node
, 1))
1054 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1055 infer them and MEM_ATTR caching will share MEM_REFs
1056 with differently-typed op0s. */
1057 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1058 /* Released SSA_NAMES have no TREE_TYPE. */
1059 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1060 /* Same pointer types, but ignoring POINTER_TYPE vs.
1062 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1063 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1064 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1065 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1066 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1067 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1068 /* Same value types ignoring qualifiers. */
1069 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1070 == TYPE_MAIN_VARIANT
1071 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))))
1073 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1076 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1080 dump_generic_node (buffer
,
1081 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1088 pp_string (buffer
, "MEM[");
1089 pp_left_paren (buffer
);
1090 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1091 dump_generic_node (buffer
, ptype
,
1092 spc
, flags
| TDF_SLIM
, false);
1093 pp_right_paren (buffer
);
1094 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1096 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1098 pp_string (buffer
, " + ");
1099 dump_generic_node (buffer
, TREE_OPERAND (node
, 1),
1102 pp_right_bracket (buffer
);
1107 case TARGET_MEM_REF
:
1109 const char *sep
= "";
1112 pp_string (buffer
, "MEM[");
1114 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1116 pp_string (buffer
, sep
);
1118 pp_string (buffer
, "symbol: ");
1119 dump_generic_node (buffer
, TREE_OPERAND (TMR_BASE (node
), 0),
1124 pp_string (buffer
, sep
);
1126 pp_string (buffer
, "base: ");
1127 dump_generic_node (buffer
, TMR_BASE (node
), spc
, flags
, false);
1129 tmp
= TMR_INDEX2 (node
);
1132 pp_string (buffer
, sep
);
1134 pp_string (buffer
, "base: ");
1135 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1137 tmp
= TMR_INDEX (node
);
1140 pp_string (buffer
, sep
);
1142 pp_string (buffer
, "index: ");
1143 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1145 tmp
= TMR_STEP (node
);
1148 pp_string (buffer
, sep
);
1150 pp_string (buffer
, "step: ");
1151 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1153 tmp
= TMR_OFFSET (node
);
1156 pp_string (buffer
, sep
);
1158 pp_string (buffer
, "offset: ");
1159 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1161 pp_right_bracket (buffer
);
1169 /* Print the innermost component type. */
1170 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1171 tmp
= TREE_TYPE (tmp
))
1173 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1175 /* Print the dimensions. */
1176 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1177 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
1183 case QUAL_UNION_TYPE
:
1185 unsigned int quals
= TYPE_QUALS (node
);
1187 if (quals
& TYPE_QUAL_ATOMIC
)
1188 pp_string (buffer
, "atomic ");
1189 if (quals
& TYPE_QUAL_CONST
)
1190 pp_string (buffer
, "const ");
1191 if (quals
& TYPE_QUAL_VOLATILE
)
1192 pp_string (buffer
, "volatile ");
1194 /* Print the name of the structure. */
1195 if (TREE_CODE (node
) == RECORD_TYPE
)
1196 pp_string (buffer
, "struct ");
1197 else if (TREE_CODE (node
) == UNION_TYPE
)
1198 pp_string (buffer
, "union ");
1200 if (TYPE_NAME (node
))
1201 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, flags
, false);
1202 else if (!(flags
& TDF_SLIM
))
1203 /* FIXME: If we eliminate the 'else' above and attempt
1204 to show the fields for named types, we may get stuck
1205 following a cycle of pointers to structs. The alleged
1206 self-reference check in print_struct_decl will not detect
1207 cycles involving more than one pointer or struct type. */
1208 print_struct_decl (buffer
, node
, spc
, flags
);
1217 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
1219 /* In the case of a pointer, one may want to divide by the
1220 size of the pointed-to type. Unfortunately, this not
1221 straightforward. The C front-end maps expressions
1226 in such a way that the two INTEGER_CST nodes for "5" have
1227 different values but identical types. In the latter
1228 case, the 5 is multiplied by sizeof (int) in c-common.c
1229 (pointer_int_sum) to convert it to a byte address, and
1230 yet the type of the node is left unchanged. Argh. What
1231 is consistent though is that the number value corresponds
1232 to bytes (UNITS) offset.
1234 NB: Neither of the following divisors can be trivially
1235 used to recover the original literal:
1237 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1238 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1239 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
1240 pp_string (buffer
, "B"); /* pseudo-unit */
1242 else if (tree_fits_shwi_p (node
))
1243 pp_wide_integer (buffer
, tree_to_shwi (node
));
1244 else if (tree_fits_uhwi_p (node
))
1245 pp_unsigned_wide_integer (buffer
, tree_to_uhwi (node
));
1248 wide_int val
= node
;
1250 if (wi::neg_p (val
, TYPE_SIGN (TREE_TYPE (node
))))
1255 print_hex (val
, pp_buffer (buffer
)->digit_buffer
);
1256 pp_string (buffer
, pp_buffer (buffer
)->digit_buffer
);
1258 if (TREE_OVERFLOW (node
))
1259 pp_string (buffer
, "(OVF)");
1263 /* Code copied from print_node. */
1266 if (TREE_OVERFLOW (node
))
1267 pp_string (buffer
, " overflow");
1269 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
1270 d
= TREE_REAL_CST (node
);
1271 if (REAL_VALUE_ISINF (d
))
1272 pp_string (buffer
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1273 else if (REAL_VALUE_ISNAN (d
))
1274 pp_string (buffer
, " Nan");
1278 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1279 pp_string (buffer
, string
);
1284 unsigned char *p
= (unsigned char *) &TREE_REAL_CST (node
);
1285 pp_string (buffer
, "0x");
1286 for (i
= 0; i
< sizeof TREE_REAL_CST (node
); i
++)
1287 output_formatted_integer (buffer
, "%02x", *p
++);
1296 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1297 pp_string (buffer
, string
);
1302 pp_string (buffer
, "__complex__ (");
1303 dump_generic_node (buffer
, TREE_REALPART (node
), spc
, flags
, false);
1304 pp_string (buffer
, ", ");
1305 dump_generic_node (buffer
, TREE_IMAGPART (node
), spc
, flags
, false);
1306 pp_right_paren (buffer
);
1310 pp_string (buffer
, "\"");
1311 pretty_print_string (buffer
, TREE_STRING_POINTER (node
));
1312 pp_string (buffer
, "\"");
1318 pp_string (buffer
, "{ ");
1319 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1322 pp_string (buffer
, ", ");
1323 dump_generic_node (buffer
, VECTOR_CST_ELT (node
, i
),
1326 pp_string (buffer
, " }");
1332 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1334 if (TREE_CODE (node
) == METHOD_TYPE
)
1336 if (TYPE_METHOD_BASETYPE (node
))
1337 dump_decl_name (buffer
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1340 pp_string (buffer
, "<null method basetype>");
1341 pp_colon_colon (buffer
);
1343 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1344 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
1345 else if (flags
& TDF_NOUID
)
1346 pp_printf (buffer
, "<Txxxx>");
1348 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
1349 dump_function_declaration (buffer
, node
, spc
, flags
);
1354 dump_decl_name (buffer
, node
, flags
);
1358 if (DECL_NAME (node
))
1359 dump_decl_name (buffer
, node
, flags
);
1360 else if (LABEL_DECL_UID (node
) != -1)
1361 pp_printf (buffer
, "<L%d>", (int) LABEL_DECL_UID (node
));
1364 if (flags
& TDF_NOUID
)
1365 pp_string (buffer
, "<D.xxxx>");
1367 pp_printf (buffer
, "<D.%u>", DECL_UID (node
));
1372 if (DECL_IS_BUILTIN (node
))
1374 /* Don't print the declaration of built-in types. */
1377 if (DECL_NAME (node
))
1378 dump_decl_name (buffer
, node
, flags
);
1379 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1381 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1382 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1383 && TYPE_METHODS (TREE_TYPE (node
)))
1385 /* The type is a c++ class: all structures have at least
1387 pp_string (buffer
, "class ");
1388 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1393 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1394 ? "union" : "struct "));
1395 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1399 pp_string (buffer
, "<anon>");
1405 case DEBUG_EXPR_DECL
:
1406 case NAMESPACE_DECL
:
1407 dump_decl_name (buffer
, node
, flags
);
1411 pp_string (buffer
, "<retval>");
1415 op0
= TREE_OPERAND (node
, 0);
1418 && (TREE_CODE (op0
) == INDIRECT_REF
1419 || (TREE_CODE (op0
) == MEM_REF
1420 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1421 && integer_zerop (TREE_OPERAND (op0
, 1))
1422 /* Dump the types of INTEGER_CSTs explicitly, for we
1423 can't infer them and MEM_ATTR caching will share
1424 MEM_REFs with differently-typed op0s. */
1425 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1426 /* Released SSA_NAMES have no TREE_TYPE. */
1427 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1428 /* Same pointer types, but ignoring POINTER_TYPE vs.
1430 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1431 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1432 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1433 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1434 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1435 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1436 /* Same value types ignoring qualifiers. */
1437 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1438 == TYPE_MAIN_VARIANT
1439 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))))))
1441 op0
= TREE_OPERAND (op0
, 0);
1444 if (op_prio (op0
) < op_prio (node
))
1445 pp_left_paren (buffer
);
1446 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1447 if (op_prio (op0
) < op_prio (node
))
1448 pp_right_paren (buffer
);
1449 pp_string (buffer
, str
);
1450 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1451 op0
= component_ref_field_offset (node
);
1452 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1454 pp_string (buffer
, "{off: ");
1455 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1456 pp_right_brace (buffer
);
1461 pp_string (buffer
, "BIT_FIELD_REF <");
1462 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1463 pp_string (buffer
, ", ");
1464 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1465 pp_string (buffer
, ", ");
1466 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1467 pp_greater (buffer
);
1471 case ARRAY_RANGE_REF
:
1472 op0
= TREE_OPERAND (node
, 0);
1473 if (op_prio (op0
) < op_prio (node
))
1474 pp_left_paren (buffer
);
1475 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1476 if (op_prio (op0
) < op_prio (node
))
1477 pp_right_paren (buffer
);
1478 pp_left_bracket (buffer
);
1479 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1480 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1481 pp_string (buffer
, " ...");
1482 pp_right_bracket (buffer
);
1484 op0
= array_ref_low_bound (node
);
1485 op1
= array_ref_element_size (node
);
1487 if (!integer_zerop (op0
)
1488 || TREE_OPERAND (node
, 2)
1489 || TREE_OPERAND (node
, 3))
1491 pp_string (buffer
, "{lb: ");
1492 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1493 pp_string (buffer
, " sz: ");
1494 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1495 pp_right_brace (buffer
);
1501 unsigned HOST_WIDE_INT ix
;
1503 bool is_struct_init
= false;
1504 bool is_array_init
= false;
1506 pp_left_brace (buffer
);
1507 if (TREE_CLOBBER_P (node
))
1508 pp_string (buffer
, "CLOBBER");
1509 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1510 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1511 is_struct_init
= true;
1512 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
1513 && TYPE_DOMAIN (TREE_TYPE (node
))
1514 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
1515 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
1518 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
1519 is_array_init
= true;
1520 curidx
= wi::to_widest (minv
);
1522 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1529 dump_generic_node (buffer
, field
, spc
, flags
, false);
1532 else if (is_array_init
1533 && (TREE_CODE (field
) != INTEGER_CST
1534 || curidx
!= wi::to_widest (field
)))
1536 pp_left_bracket (buffer
);
1537 if (TREE_CODE (field
) == RANGE_EXPR
)
1539 dump_generic_node (buffer
, TREE_OPERAND (field
, 0), spc
,
1541 pp_string (buffer
, " ... ");
1542 dump_generic_node (buffer
, TREE_OPERAND (field
, 1), spc
,
1544 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
1545 curidx
= wi::to_widest (TREE_OPERAND (field
, 1));
1548 dump_generic_node (buffer
, field
, spc
, flags
, false);
1549 if (TREE_CODE (field
) == INTEGER_CST
)
1550 curidx
= wi::to_widest (field
);
1551 pp_string (buffer
, "]=");
1556 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1557 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1558 val
= TREE_OPERAND (val
, 0);
1559 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1560 dump_decl_name (buffer
, val
, flags
);
1562 dump_generic_node (buffer
, val
, spc
, flags
, false);
1563 if (ix
!= vec_safe_length (CONSTRUCTOR_ELTS (node
)) - 1)
1569 pp_right_brace (buffer
);
1576 if (flags
& TDF_SLIM
)
1578 pp_string (buffer
, "<COMPOUND_EXPR>");
1582 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1583 spc
, flags
, !(flags
& TDF_SLIM
));
1584 if (flags
& TDF_SLIM
)
1585 newline_and_indent (buffer
, spc
);
1592 for (tp
= &TREE_OPERAND (node
, 1);
1593 TREE_CODE (*tp
) == COMPOUND_EXPR
;
1594 tp
= &TREE_OPERAND (*tp
, 1))
1596 dump_generic_node (buffer
, TREE_OPERAND (*tp
, 0),
1597 spc
, flags
, !(flags
& TDF_SLIM
));
1598 if (flags
& TDF_SLIM
)
1599 newline_and_indent (buffer
, spc
);
1607 dump_generic_node (buffer
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
1611 case STATEMENT_LIST
:
1613 tree_stmt_iterator si
;
1616 if (flags
& TDF_SLIM
)
1618 pp_string (buffer
, "<STATEMENT_LIST>");
1622 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
1625 newline_and_indent (buffer
, spc
);
1628 dump_generic_node (buffer
, tsi_stmt (si
), spc
, flags
, true);
1635 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
,
1640 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
,
1645 pp_string (buffer
, "TARGET_EXPR <");
1646 dump_generic_node (buffer
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
1649 dump_generic_node (buffer
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
1650 pp_greater (buffer
);
1654 print_declaration (buffer
, DECL_EXPR_DECL (node
), spc
, flags
);
1659 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
1661 pp_string (buffer
, "if (");
1662 dump_generic_node (buffer
, COND_EXPR_COND (node
), spc
, flags
, false);
1663 pp_right_paren (buffer
);
1664 /* The lowered cond_exprs should always be printed in full. */
1665 if (COND_EXPR_THEN (node
)
1666 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
1667 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
1668 && COND_EXPR_ELSE (node
)
1669 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
1670 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
1673 dump_generic_node (buffer
, COND_EXPR_THEN (node
),
1675 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1677 pp_string (buffer
, " else ");
1678 dump_generic_node (buffer
, COND_EXPR_ELSE (node
),
1682 else if (!(flags
& TDF_SLIM
))
1684 /* Output COND_EXPR_THEN. */
1685 if (COND_EXPR_THEN (node
))
1687 newline_and_indent (buffer
, spc
+2);
1688 pp_left_brace (buffer
);
1689 newline_and_indent (buffer
, spc
+4);
1690 dump_generic_node (buffer
, COND_EXPR_THEN (node
), spc
+4,
1692 newline_and_indent (buffer
, spc
+2);
1693 pp_right_brace (buffer
);
1696 /* Output COND_EXPR_ELSE. */
1697 if (COND_EXPR_ELSE (node
)
1698 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1700 newline_and_indent (buffer
, spc
);
1701 pp_string (buffer
, "else");
1702 newline_and_indent (buffer
, spc
+2);
1703 pp_left_brace (buffer
);
1704 newline_and_indent (buffer
, spc
+4);
1705 dump_generic_node (buffer
, COND_EXPR_ELSE (node
), spc
+4,
1707 newline_and_indent (buffer
, spc
+2);
1708 pp_right_brace (buffer
);
1715 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1717 pp_question (buffer
);
1719 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1723 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1728 pp_left_brace (buffer
);
1729 if (!(flags
& TDF_SLIM
))
1731 if (BIND_EXPR_VARS (node
))
1733 pp_newline (buffer
);
1735 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
1737 print_declaration (buffer
, op0
, spc
+2, flags
);
1738 pp_newline (buffer
);
1742 newline_and_indent (buffer
, spc
+2);
1743 dump_generic_node (buffer
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
1744 newline_and_indent (buffer
, spc
);
1745 pp_right_brace (buffer
);
1751 print_call_name (buffer
, CALL_EXPR_FN (node
), flags
);
1753 /* Print parameters. */
1755 pp_left_paren (buffer
);
1758 call_expr_arg_iterator iter
;
1759 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
1761 dump_generic_node (buffer
, arg
, spc
, flags
, false);
1762 if (more_call_expr_args_p (&iter
))
1769 if (CALL_EXPR_VA_ARG_PACK (node
))
1771 if (call_expr_nargs (node
) > 0)
1776 pp_string (buffer
, "__builtin_va_arg_pack ()");
1778 pp_right_paren (buffer
);
1780 op1
= CALL_EXPR_STATIC_CHAIN (node
);
1783 pp_string (buffer
, " [static-chain: ");
1784 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1785 pp_right_bracket (buffer
);
1788 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
1789 pp_string (buffer
, " [return slot optimization]");
1790 if (CALL_EXPR_TAILCALL (node
))
1791 pp_string (buffer
, " [tail call]");
1794 case WITH_CLEANUP_EXPR
:
1798 case CLEANUP_POINT_EXPR
:
1799 pp_string (buffer
, "<<cleanup_point ");
1800 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1801 pp_string (buffer
, ">>");
1804 case PLACEHOLDER_EXPR
:
1805 pp_string (buffer
, "<PLACEHOLDER_EXPR ");
1806 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1807 pp_greater (buffer
);
1810 /* Binary arithmetic and logic expressions. */
1811 case WIDEN_SUM_EXPR
:
1812 case WIDEN_MULT_EXPR
:
1814 case MULT_HIGHPART_EXPR
:
1816 case POINTER_PLUS_EXPR
:
1818 case TRUNC_DIV_EXPR
:
1820 case FLOOR_DIV_EXPR
:
1821 case ROUND_DIV_EXPR
:
1822 case TRUNC_MOD_EXPR
:
1824 case FLOOR_MOD_EXPR
:
1825 case ROUND_MOD_EXPR
:
1827 case EXACT_DIV_EXPR
:
1832 case VEC_LSHIFT_EXPR
:
1833 case VEC_RSHIFT_EXPR
:
1834 case WIDEN_LSHIFT_EXPR
:
1838 case TRUTH_ANDIF_EXPR
:
1839 case TRUTH_ORIF_EXPR
:
1840 case TRUTH_AND_EXPR
:
1842 case TRUTH_XOR_EXPR
:
1856 case UNORDERED_EXPR
:
1858 const char *op
= op_symbol (node
);
1859 op0
= TREE_OPERAND (node
, 0);
1860 op1
= TREE_OPERAND (node
, 1);
1862 /* When the operands are expressions with less priority,
1863 keep semantics of the tree representation. */
1864 if (op_prio (op0
) <= op_prio (node
))
1866 pp_left_paren (buffer
);
1867 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1868 pp_right_paren (buffer
);
1871 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1874 pp_string (buffer
, op
);
1877 /* When the operands are expressions with less priority,
1878 keep semantics of the tree representation. */
1879 if (op_prio (op1
) <= op_prio (node
))
1881 pp_left_paren (buffer
);
1882 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1883 pp_right_paren (buffer
);
1886 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1890 /* Unary arithmetic and logic expressions. */
1893 case TRUTH_NOT_EXPR
:
1895 case PREDECREMENT_EXPR
:
1896 case PREINCREMENT_EXPR
:
1898 if (TREE_CODE (node
) == ADDR_EXPR
1899 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
1900 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
1901 ; /* Do not output '&' for strings and function pointers. */
1903 pp_string (buffer
, op_symbol (node
));
1905 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1907 pp_left_paren (buffer
);
1908 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1909 pp_right_paren (buffer
);
1912 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1915 case POSTDECREMENT_EXPR
:
1916 case POSTINCREMENT_EXPR
:
1917 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1919 pp_left_paren (buffer
);
1920 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1921 pp_right_paren (buffer
);
1924 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1925 pp_string (buffer
, op_symbol (node
));
1929 pp_string (buffer
, "MIN_EXPR <");
1930 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1931 pp_string (buffer
, ", ");
1932 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1933 pp_greater (buffer
);
1937 pp_string (buffer
, "MAX_EXPR <");
1938 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1939 pp_string (buffer
, ", ");
1940 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1941 pp_greater (buffer
);
1945 pp_string (buffer
, "ABS_EXPR <");
1946 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1947 pp_greater (buffer
);
1954 case ADDR_SPACE_CONVERT_EXPR
:
1955 case FIXED_CONVERT_EXPR
:
1956 case FIX_TRUNC_EXPR
:
1959 type
= TREE_TYPE (node
);
1960 op0
= TREE_OPERAND (node
, 0);
1961 if (type
!= TREE_TYPE (op0
))
1963 pp_left_paren (buffer
);
1964 dump_generic_node (buffer
, type
, spc
, flags
, false);
1965 pp_string (buffer
, ") ");
1967 if (op_prio (op0
) < op_prio (node
))
1968 pp_left_paren (buffer
);
1969 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1970 if (op_prio (op0
) < op_prio (node
))
1971 pp_right_paren (buffer
);
1974 case VIEW_CONVERT_EXPR
:
1975 pp_string (buffer
, "VIEW_CONVERT_EXPR<");
1976 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1977 pp_string (buffer
, ">(");
1978 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1979 pp_right_paren (buffer
);
1983 pp_string (buffer
, "((");
1984 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1985 pp_string (buffer
, "))");
1988 case NON_LVALUE_EXPR
:
1989 pp_string (buffer
, "NON_LVALUE_EXPR <");
1990 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1991 pp_greater (buffer
);
1995 pp_string (buffer
, "SAVE_EXPR <");
1996 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1997 pp_greater (buffer
);
2001 pp_string (buffer
, "COMPLEX_EXPR <");
2002 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2003 pp_string (buffer
, ", ");
2004 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2005 pp_greater (buffer
);
2009 pp_string (buffer
, "CONJ_EXPR <");
2010 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2011 pp_greater (buffer
);
2015 pp_string (buffer
, "REALPART_EXPR <");
2016 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2017 pp_greater (buffer
);
2021 pp_string (buffer
, "IMAGPART_EXPR <");
2022 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2023 pp_greater (buffer
);
2027 pp_string (buffer
, "VA_ARG_EXPR <");
2028 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2029 pp_greater (buffer
);
2032 case TRY_FINALLY_EXPR
:
2033 case TRY_CATCH_EXPR
:
2034 pp_string (buffer
, "try");
2035 newline_and_indent (buffer
, spc
+2);
2036 pp_left_brace (buffer
);
2037 newline_and_indent (buffer
, spc
+4);
2038 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2039 newline_and_indent (buffer
, spc
+2);
2040 pp_right_brace (buffer
);
2041 newline_and_indent (buffer
, spc
);
2043 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2044 newline_and_indent (buffer
, spc
+2);
2045 pp_left_brace (buffer
);
2046 newline_and_indent (buffer
, spc
+4);
2047 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2048 newline_and_indent (buffer
, spc
+2);
2049 pp_right_brace (buffer
);
2054 pp_string (buffer
, "catch (");
2055 dump_generic_node (buffer
, CATCH_TYPES (node
), spc
+2, flags
, false);
2056 pp_right_paren (buffer
);
2057 newline_and_indent (buffer
, spc
+2);
2058 pp_left_brace (buffer
);
2059 newline_and_indent (buffer
, spc
+4);
2060 dump_generic_node (buffer
, CATCH_BODY (node
), spc
+4, flags
, true);
2061 newline_and_indent (buffer
, spc
+2);
2062 pp_right_brace (buffer
);
2066 case EH_FILTER_EXPR
:
2067 pp_string (buffer
, "<<<eh_filter (");
2068 dump_generic_node (buffer
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2069 pp_string (buffer
, ")>>>");
2070 newline_and_indent (buffer
, spc
+2);
2071 pp_left_brace (buffer
);
2072 newline_and_indent (buffer
, spc
+4);
2073 dump_generic_node (buffer
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2074 newline_and_indent (buffer
, spc
+2);
2075 pp_right_brace (buffer
);
2080 op0
= TREE_OPERAND (node
, 0);
2081 /* If this is for break or continue, don't bother printing it. */
2082 if (DECL_NAME (op0
))
2084 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2085 if (strcmp (name
, "break") == 0
2086 || strcmp (name
, "continue") == 0)
2089 dump_generic_node (buffer
, op0
, spc
, flags
, false);
2091 if (DECL_NONLOCAL (op0
))
2092 pp_string (buffer
, " [non-local]");
2096 pp_string (buffer
, "while (1)");
2097 if (!(flags
& TDF_SLIM
))
2099 newline_and_indent (buffer
, spc
+2);
2100 pp_left_brace (buffer
);
2101 newline_and_indent (buffer
, spc
+4);
2102 dump_generic_node (buffer
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2103 newline_and_indent (buffer
, spc
+2);
2104 pp_right_brace (buffer
);
2110 pp_string (buffer
, "// predicted ");
2111 if (PREDICT_EXPR_OUTCOME (node
))
2112 pp_string (buffer
, "likely by ");
2114 pp_string (buffer
, "unlikely by ");
2115 pp_string (buffer
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2116 pp_string (buffer
, " predictor.");
2120 pp_string (buffer
, "ANNOTATE_EXPR <");
2121 switch ((enum annot_expr_kind
) tree_to_shwi (TREE_OPERAND (node
, 1)))
2123 case annot_expr_ivdep_kind
:
2124 pp_string (buffer
, "ivdep, ");
2127 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2128 pp_greater (buffer
);
2132 pp_string (buffer
, "return");
2133 op0
= TREE_OPERAND (node
, 0);
2137 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2138 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1),
2141 dump_generic_node (buffer
, op0
, spc
, flags
, false);
2146 pp_string (buffer
, "if (");
2147 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2148 pp_string (buffer
, ") break");
2152 pp_string (buffer
, "switch (");
2153 dump_generic_node (buffer
, SWITCH_COND (node
), spc
, flags
, false);
2154 pp_right_paren (buffer
);
2155 if (!(flags
& TDF_SLIM
))
2157 newline_and_indent (buffer
, spc
+2);
2158 pp_left_brace (buffer
);
2159 if (SWITCH_BODY (node
))
2161 newline_and_indent (buffer
, spc
+4);
2162 dump_generic_node (buffer
, SWITCH_BODY (node
), spc
+4, flags
,
2167 tree vec
= SWITCH_LABELS (node
);
2168 size_t i
, n
= TREE_VEC_LENGTH (vec
);
2169 for (i
= 0; i
< n
; ++i
)
2171 tree elt
= TREE_VEC_ELT (vec
, i
);
2172 newline_and_indent (buffer
, spc
+4);
2175 dump_generic_node (buffer
, elt
, spc
+4, flags
, false);
2176 pp_string (buffer
, " goto ");
2177 dump_generic_node (buffer
, CASE_LABEL (elt
), spc
+4,
2179 pp_semicolon (buffer
);
2182 pp_string (buffer
, "case ???: goto ???;");
2185 newline_and_indent (buffer
, spc
+2);
2186 pp_right_brace (buffer
);
2192 op0
= GOTO_DESTINATION (node
);
2193 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2195 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2196 if (strcmp (name
, "break") == 0
2197 || strcmp (name
, "continue") == 0)
2199 pp_string (buffer
, name
);
2203 pp_string (buffer
, "goto ");
2204 dump_generic_node (buffer
, op0
, spc
, flags
, false);
2208 pp_string (buffer
, "__asm__");
2209 if (ASM_VOLATILE_P (node
))
2210 pp_string (buffer
, " __volatile__");
2211 pp_left_paren (buffer
);
2212 dump_generic_node (buffer
, ASM_STRING (node
), spc
, flags
, false);
2214 dump_generic_node (buffer
, ASM_OUTPUTS (node
), spc
, flags
, false);
2216 dump_generic_node (buffer
, ASM_INPUTS (node
), spc
, flags
, false);
2217 if (ASM_CLOBBERS (node
))
2220 dump_generic_node (buffer
, ASM_CLOBBERS (node
), spc
, flags
, false);
2222 pp_right_paren (buffer
);
2225 case CASE_LABEL_EXPR
:
2226 if (CASE_LOW (node
) && CASE_HIGH (node
))
2228 pp_string (buffer
, "case ");
2229 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
2230 pp_string (buffer
, " ... ");
2231 dump_generic_node (buffer
, CASE_HIGH (node
), spc
, flags
, false);
2233 else if (CASE_LOW (node
))
2235 pp_string (buffer
, "case ");
2236 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
2239 pp_string (buffer
, "default");
2244 pp_string (buffer
, "OBJ_TYPE_REF(");
2245 dump_generic_node (buffer
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2246 pp_semicolon (buffer
);
2247 if (!(flags
& TDF_SLIM
) && virtual_method_call_p (node
))
2249 pp_string (buffer
, "(");
2250 dump_generic_node (buffer
, obj_type_ref_class (node
), spc
, flags
, false);
2251 pp_string (buffer
, ")");
2253 dump_generic_node (buffer
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2255 dump_generic_node (buffer
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2256 pp_right_paren (buffer
);
2260 if (SSA_NAME_IDENTIFIER (node
))
2261 dump_generic_node (buffer
, SSA_NAME_IDENTIFIER (node
),
2263 pp_underscore (buffer
);
2264 pp_decimal_int (buffer
, SSA_NAME_VERSION (node
));
2265 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2266 pp_string (buffer
, "(D)");
2267 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2268 pp_string (buffer
, "(ab)");
2271 case WITH_SIZE_EXPR
:
2272 pp_string (buffer
, "WITH_SIZE_EXPR <");
2273 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2274 pp_string (buffer
, ", ");
2275 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2276 pp_greater (buffer
);
2280 pp_string (buffer
, "ASSERT_EXPR <");
2281 dump_generic_node (buffer
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2282 pp_string (buffer
, ", ");
2283 dump_generic_node (buffer
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2284 pp_greater (buffer
);
2288 pp_string (buffer
, "scev_known");
2291 case SCEV_NOT_KNOWN
:
2292 pp_string (buffer
, "scev_not_known");
2295 case POLYNOMIAL_CHREC
:
2296 pp_left_brace (buffer
);
2297 dump_generic_node (buffer
, CHREC_LEFT (node
), spc
, flags
, false);
2298 pp_string (buffer
, ", +, ");
2299 dump_generic_node (buffer
, CHREC_RIGHT (node
), spc
, flags
, false);
2300 pp_string (buffer
, "}_");
2301 dump_generic_node (buffer
, CHREC_VAR (node
), spc
, flags
, false);
2305 case REALIGN_LOAD_EXPR
:
2306 pp_string (buffer
, "REALIGN_LOAD <");
2307 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2308 pp_string (buffer
, ", ");
2309 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2310 pp_string (buffer
, ", ");
2311 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2312 pp_greater (buffer
);
2316 pp_string (buffer
, " VEC_COND_EXPR < ");
2317 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2318 pp_string (buffer
, " , ");
2319 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2320 pp_string (buffer
, " , ");
2321 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2322 pp_string (buffer
, " > ");
2326 pp_string (buffer
, " VEC_PERM_EXPR < ");
2327 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2328 pp_string (buffer
, " , ");
2329 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2330 pp_string (buffer
, " , ");
2331 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2332 pp_string (buffer
, " > ");
2336 pp_string (buffer
, " DOT_PROD_EXPR < ");
2337 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2338 pp_string (buffer
, ", ");
2339 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2340 pp_string (buffer
, ", ");
2341 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2342 pp_string (buffer
, " > ");
2345 case WIDEN_MULT_PLUS_EXPR
:
2346 pp_string (buffer
, " WIDEN_MULT_PLUS_EXPR < ");
2347 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2348 pp_string (buffer
, ", ");
2349 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2350 pp_string (buffer
, ", ");
2351 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2352 pp_string (buffer
, " > ");
2355 case WIDEN_MULT_MINUS_EXPR
:
2356 pp_string (buffer
, " WIDEN_MULT_MINUS_EXPR < ");
2357 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2358 pp_string (buffer
, ", ");
2359 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2360 pp_string (buffer
, ", ");
2361 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2362 pp_string (buffer
, " > ");
2366 pp_string (buffer
, " FMA_EXPR < ");
2367 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2368 pp_string (buffer
, ", ");
2369 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2370 pp_string (buffer
, ", ");
2371 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2372 pp_string (buffer
, " > ");
2376 pp_string (buffer
, "#pragma omp parallel");
2377 dump_omp_clauses (buffer
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2380 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2382 newline_and_indent (buffer
, spc
+ 2);
2383 pp_left_brace (buffer
);
2384 newline_and_indent (buffer
, spc
+ 4);
2385 dump_generic_node (buffer
, OMP_BODY (node
), spc
+ 4, flags
, false);
2386 newline_and_indent (buffer
, spc
+ 2);
2387 pp_right_brace (buffer
);
2393 pp_string (buffer
, "#pragma omp task");
2394 dump_omp_clauses (buffer
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2398 pp_string (buffer
, "#pragma omp for");
2402 pp_string (buffer
, "#pragma omp simd");
2406 pp_string (buffer
, "#pragma simd");
2409 case OMP_DISTRIBUTE
:
2410 pp_string (buffer
, "#pragma omp distribute");
2414 pp_string (buffer
, "#pragma omp teams");
2415 dump_omp_clauses (buffer
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
2418 case OMP_TARGET_DATA
:
2419 pp_string (buffer
, "#pragma omp target data");
2420 dump_omp_clauses (buffer
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
2424 pp_string (buffer
, "#pragma omp target");
2425 dump_omp_clauses (buffer
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
2428 case OMP_TARGET_UPDATE
:
2429 pp_string (buffer
, "#pragma omp target update");
2430 dump_omp_clauses (buffer
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
2435 dump_omp_clauses (buffer
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2437 if (!(flags
& TDF_SLIM
))
2441 if (OMP_FOR_PRE_BODY (node
))
2443 newline_and_indent (buffer
, spc
+ 2);
2444 pp_left_brace (buffer
);
2446 newline_and_indent (buffer
, spc
);
2447 dump_generic_node (buffer
, OMP_FOR_PRE_BODY (node
),
2450 if (OMP_FOR_INIT (node
))
2453 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
2456 newline_and_indent (buffer
, spc
);
2457 pp_string (buffer
, "for (");
2458 dump_generic_node (buffer
,
2459 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
2461 pp_string (buffer
, "; ");
2462 dump_generic_node (buffer
,
2463 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
2465 pp_string (buffer
, "; ");
2466 dump_generic_node (buffer
,
2467 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
2469 pp_right_paren (buffer
);
2472 if (OMP_FOR_BODY (node
))
2474 newline_and_indent (buffer
, spc
+ 2);
2475 pp_left_brace (buffer
);
2476 newline_and_indent (buffer
, spc
+ 4);
2477 dump_generic_node (buffer
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
2479 newline_and_indent (buffer
, spc
+ 2);
2480 pp_right_brace (buffer
);
2482 if (OMP_FOR_INIT (node
))
2483 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
2484 if (OMP_FOR_PRE_BODY (node
))
2487 newline_and_indent (buffer
, spc
+ 2);
2488 pp_right_brace (buffer
);
2495 pp_string (buffer
, "#pragma omp sections");
2496 dump_omp_clauses (buffer
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
2500 pp_string (buffer
, "#pragma omp section");
2504 pp_string (buffer
, "#pragma omp master");
2508 pp_string (buffer
, "#pragma omp taskgroup");
2512 pp_string (buffer
, "#pragma omp ordered");
2516 pp_string (buffer
, "#pragma omp critical");
2517 if (OMP_CRITICAL_NAME (node
))
2520 pp_left_paren (buffer
);
2521 dump_generic_node (buffer
, OMP_CRITICAL_NAME (node
), spc
,
2523 pp_right_paren (buffer
);
2528 pp_string (buffer
, "#pragma omp atomic");
2529 if (OMP_ATOMIC_SEQ_CST (node
))
2530 pp_string (buffer
, " seq_cst");
2531 newline_and_indent (buffer
, spc
+ 2);
2532 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2536 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2539 case OMP_ATOMIC_READ
:
2540 pp_string (buffer
, "#pragma omp atomic read");
2541 if (OMP_ATOMIC_SEQ_CST (node
))
2542 pp_string (buffer
, " seq_cst");
2543 newline_and_indent (buffer
, spc
+ 2);
2544 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2548 case OMP_ATOMIC_CAPTURE_OLD
:
2549 case OMP_ATOMIC_CAPTURE_NEW
:
2550 pp_string (buffer
, "#pragma omp atomic capture");
2551 if (OMP_ATOMIC_SEQ_CST (node
))
2552 pp_string (buffer
, " seq_cst");
2553 newline_and_indent (buffer
, spc
+ 2);
2554 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2558 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2562 pp_string (buffer
, "#pragma omp single");
2563 dump_omp_clauses (buffer
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
2567 dump_omp_clause (buffer
, node
, spc
, flags
);
2571 case TRANSACTION_EXPR
:
2572 if (TRANSACTION_EXPR_OUTER (node
))
2573 pp_string (buffer
, "__transaction_atomic [[outer]]");
2574 else if (TRANSACTION_EXPR_RELAXED (node
))
2575 pp_string (buffer
, "__transaction_relaxed");
2577 pp_string (buffer
, "__transaction_atomic");
2578 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
2580 newline_and_indent (buffer
, spc
);
2581 pp_left_brace (buffer
);
2582 newline_and_indent (buffer
, spc
+ 2);
2583 dump_generic_node (buffer
, TRANSACTION_EXPR_BODY (node
),
2584 spc
+ 2, flags
, false);
2585 newline_and_indent (buffer
, spc
);
2586 pp_right_brace (buffer
);
2591 case REDUC_MAX_EXPR
:
2592 pp_string (buffer
, " REDUC_MAX_EXPR < ");
2593 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2594 pp_string (buffer
, " > ");
2597 case REDUC_MIN_EXPR
:
2598 pp_string (buffer
, " REDUC_MIN_EXPR < ");
2599 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2600 pp_string (buffer
, " > ");
2603 case REDUC_PLUS_EXPR
:
2604 pp_string (buffer
, " REDUC_PLUS_EXPR < ");
2605 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2606 pp_string (buffer
, " > ");
2609 case VEC_WIDEN_MULT_HI_EXPR
:
2610 case VEC_WIDEN_MULT_LO_EXPR
:
2611 case VEC_WIDEN_MULT_EVEN_EXPR
:
2612 case VEC_WIDEN_MULT_ODD_EXPR
:
2613 case VEC_WIDEN_LSHIFT_HI_EXPR
:
2614 case VEC_WIDEN_LSHIFT_LO_EXPR
:
2616 for (str
= get_tree_code_name (code
); *str
; str
++)
2617 pp_character (buffer
, TOUPPER (*str
));
2618 pp_string (buffer
, " < ");
2619 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2620 pp_string (buffer
, ", ");
2621 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2622 pp_string (buffer
, " > ");
2625 case VEC_UNPACK_HI_EXPR
:
2626 pp_string (buffer
, " VEC_UNPACK_HI_EXPR < ");
2627 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2628 pp_string (buffer
, " > ");
2631 case VEC_UNPACK_LO_EXPR
:
2632 pp_string (buffer
, " VEC_UNPACK_LO_EXPR < ");
2633 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2634 pp_string (buffer
, " > ");
2637 case VEC_UNPACK_FLOAT_HI_EXPR
:
2638 pp_string (buffer
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2639 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2640 pp_string (buffer
, " > ");
2643 case VEC_UNPACK_FLOAT_LO_EXPR
:
2644 pp_string (buffer
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2645 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2646 pp_string (buffer
, " > ");
2649 case VEC_PACK_TRUNC_EXPR
:
2650 pp_string (buffer
, " VEC_PACK_TRUNC_EXPR < ");
2651 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2652 pp_string (buffer
, ", ");
2653 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2654 pp_string (buffer
, " > ");
2657 case VEC_PACK_SAT_EXPR
:
2658 pp_string (buffer
, " VEC_PACK_SAT_EXPR < ");
2659 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2660 pp_string (buffer
, ", ");
2661 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2662 pp_string (buffer
, " > ");
2665 case VEC_PACK_FIX_TRUNC_EXPR
:
2666 pp_string (buffer
, " VEC_PACK_FIX_TRUNC_EXPR < ");
2667 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2668 pp_string (buffer
, ", ");
2669 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2670 pp_string (buffer
, " > ");
2674 dump_block_node (buffer
, node
, spc
, flags
);
2677 case CILK_SPAWN_STMT
:
2678 pp_string (buffer
, "_Cilk_spawn ");
2679 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2682 case CILK_SYNC_STMT
:
2683 pp_string (buffer
, "_Cilk_sync");
2690 if (is_stmt
&& is_expr
)
2691 pp_semicolon (buffer
);
2696 /* Print the declaration of a variable. */
2699 print_declaration (pretty_printer
*buffer
, tree t
, int spc
, int flags
)
2703 if (TREE_CODE (t
) == TYPE_DECL
)
2704 pp_string (buffer
, "typedef ");
2706 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
2707 pp_string (buffer
, "register ");
2709 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
2710 pp_string (buffer
, "extern ");
2711 else if (TREE_STATIC (t
))
2712 pp_string (buffer
, "static ");
2714 /* Print the type and name. */
2715 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
2719 /* Print array's type. */
2720 tmp
= TREE_TYPE (t
);
2721 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
2722 tmp
= TREE_TYPE (tmp
);
2723 dump_generic_node (buffer
, TREE_TYPE (tmp
), spc
, flags
, false);
2725 /* Print variable's name. */
2727 dump_generic_node (buffer
, t
, spc
, flags
, false);
2729 /* Print the dimensions. */
2730 tmp
= TREE_TYPE (t
);
2731 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
2733 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
2734 tmp
= TREE_TYPE (tmp
);
2737 else if (TREE_CODE (t
) == FUNCTION_DECL
)
2739 dump_generic_node (buffer
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
2741 dump_decl_name (buffer
, t
, flags
);
2742 dump_function_declaration (buffer
, TREE_TYPE (t
), spc
, flags
);
2746 /* Print type declaration. */
2747 dump_generic_node (buffer
, TREE_TYPE (t
), spc
, flags
, false);
2749 /* Print variable's name. */
2751 dump_generic_node (buffer
, t
, spc
, flags
, false);
2754 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
2756 pp_string (buffer
, " __asm__ ");
2757 pp_left_paren (buffer
);
2758 dump_generic_node (buffer
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
2759 pp_right_paren (buffer
);
2762 /* The initial value of a function serves to determine whether the function
2763 is declared or defined. So the following does not apply to function
2765 if (TREE_CODE (t
) != FUNCTION_DECL
)
2767 /* Print the initial value. */
2768 if (DECL_INITIAL (t
))
2773 dump_generic_node (buffer
, DECL_INITIAL (t
), spc
, flags
, false);
2777 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
2779 pp_string (buffer
, " [value-expr: ");
2780 dump_generic_node (buffer
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
2781 pp_right_bracket (buffer
);
2784 pp_semicolon (buffer
);
2788 /* Prints a structure: name, fields, and methods.
2789 FIXME: Still incomplete. */
2792 print_struct_decl (pretty_printer
*buffer
, const_tree node
, int spc
, int flags
)
2794 /* Print the name of the structure. */
2795 if (TYPE_NAME (node
))
2798 if (TREE_CODE (node
) == RECORD_TYPE
)
2799 pp_string (buffer
, "struct ");
2800 else if ((TREE_CODE (node
) == UNION_TYPE
2801 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
2802 pp_string (buffer
, "union ");
2804 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, 0, false);
2807 /* Print the contents of the structure. */
2808 pp_newline (buffer
);
2810 pp_left_brace (buffer
);
2811 pp_newline (buffer
);
2813 /* Print the fields of the structure. */
2816 tmp
= TYPE_FIELDS (node
);
2819 /* Avoid to print recursively the structure. */
2820 /* FIXME : Not implemented correctly...,
2821 what about the case when we have a cycle in the contain graph? ...
2822 Maybe this could be solved by looking at the scope in which the
2823 structure was declared. */
2824 if (TREE_TYPE (tmp
) != node
2825 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
2826 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
2828 print_declaration (buffer
, tmp
, spc
+2, flags
);
2829 pp_newline (buffer
);
2831 tmp
= DECL_CHAIN (tmp
);
2835 pp_right_brace (buffer
);
2838 /* Return the priority of the operator CODE.
2840 From lowest to highest precedence with either left-to-right (L-R)
2841 or right-to-left (R-L) associativity]:
2844 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2856 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2857 15 [L-R] fn() [] -> .
2859 unary +, - and * have higher precedence than the corresponding binary
2863 op_code_prio (enum tree_code code
)
2880 case TRUTH_ORIF_EXPR
:
2883 case TRUTH_AND_EXPR
:
2884 case TRUTH_ANDIF_EXPR
:
2891 case TRUTH_XOR_EXPR
:
2908 case UNORDERED_EXPR
:
2919 case VEC_WIDEN_LSHIFT_HI_EXPR
:
2920 case VEC_WIDEN_LSHIFT_LO_EXPR
:
2921 case WIDEN_LSHIFT_EXPR
:
2924 case WIDEN_SUM_EXPR
:
2926 case POINTER_PLUS_EXPR
:
2930 case VEC_WIDEN_MULT_HI_EXPR
:
2931 case VEC_WIDEN_MULT_LO_EXPR
:
2932 case WIDEN_MULT_EXPR
:
2934 case WIDEN_MULT_PLUS_EXPR
:
2935 case WIDEN_MULT_MINUS_EXPR
:
2937 case MULT_HIGHPART_EXPR
:
2938 case TRUNC_DIV_EXPR
:
2940 case FLOOR_DIV_EXPR
:
2941 case ROUND_DIV_EXPR
:
2943 case EXACT_DIV_EXPR
:
2944 case TRUNC_MOD_EXPR
:
2946 case FLOOR_MOD_EXPR
:
2947 case ROUND_MOD_EXPR
:
2951 case TRUTH_NOT_EXPR
:
2953 case POSTINCREMENT_EXPR
:
2954 case POSTDECREMENT_EXPR
:
2955 case PREINCREMENT_EXPR
:
2956 case PREDECREMENT_EXPR
:
2962 case FIX_TRUNC_EXPR
:
2968 case ARRAY_RANGE_REF
:
2972 /* Special expressions. */
2978 case REDUC_MAX_EXPR
:
2979 case REDUC_MIN_EXPR
:
2980 case REDUC_PLUS_EXPR
:
2981 case VEC_LSHIFT_EXPR
:
2982 case VEC_RSHIFT_EXPR
:
2983 case VEC_UNPACK_HI_EXPR
:
2984 case VEC_UNPACK_LO_EXPR
:
2985 case VEC_UNPACK_FLOAT_HI_EXPR
:
2986 case VEC_UNPACK_FLOAT_LO_EXPR
:
2987 case VEC_PACK_TRUNC_EXPR
:
2988 case VEC_PACK_SAT_EXPR
:
2992 /* Return an arbitrarily high precedence to avoid surrounding single
2993 VAR_DECLs in ()s. */
2998 /* Return the priority of the operator OP. */
3001 op_prio (const_tree op
)
3003 enum tree_code code
;
3008 code
= TREE_CODE (op
);
3009 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3010 return op_prio (TREE_OPERAND (op
, 0));
3012 return op_code_prio (code
);
3015 /* Return the symbol associated with operator CODE. */
3018 op_symbol_code (enum tree_code code
)
3026 case TRUTH_ORIF_EXPR
:
3029 case TRUTH_AND_EXPR
:
3030 case TRUTH_ANDIF_EXPR
:
3036 case TRUTH_XOR_EXPR
:
3046 case UNORDERED_EXPR
:
3092 case VEC_LSHIFT_EXPR
:
3095 case VEC_RSHIFT_EXPR
:
3098 case WIDEN_LSHIFT_EXPR
:
3101 case POINTER_PLUS_EXPR
:
3107 case REDUC_PLUS_EXPR
:
3110 case WIDEN_SUM_EXPR
:
3113 case WIDEN_MULT_EXPR
:
3116 case MULT_HIGHPART_EXPR
:
3126 case TRUTH_NOT_EXPR
:
3133 case TRUNC_DIV_EXPR
:
3140 case FLOOR_DIV_EXPR
:
3143 case ROUND_DIV_EXPR
:
3146 case EXACT_DIV_EXPR
:
3149 case TRUNC_MOD_EXPR
:
3155 case FLOOR_MOD_EXPR
:
3158 case ROUND_MOD_EXPR
:
3161 case PREDECREMENT_EXPR
:
3164 case PREINCREMENT_EXPR
:
3167 case POSTDECREMENT_EXPR
:
3170 case POSTINCREMENT_EXPR
:
3180 return "<<< ??? >>>";
3184 /* Return the symbol associated with operator OP. */
3187 op_symbol (const_tree op
)
3189 return op_symbol_code (TREE_CODE (op
));
3192 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3193 the gimple_call_fn of a GIMPLE_CALL. */
3196 print_call_name (pretty_printer
*buffer
, tree node
, int flags
)
3200 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3201 op0
= TREE_OPERAND (op0
, 0);
3204 switch (TREE_CODE (op0
))
3209 dump_function_name (buffer
, op0
, flags
);
3215 op0
= TREE_OPERAND (op0
, 0);
3219 pp_left_paren (buffer
);
3220 dump_generic_node (buffer
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3221 pp_string (buffer
, ") ? ");
3222 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3223 pp_string (buffer
, " : ");
3224 dump_generic_node (buffer
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3228 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3229 dump_function_name (buffer
, TREE_OPERAND (op0
, 0), flags
);
3231 dump_generic_node (buffer
, op0
, 0, flags
, false);
3235 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3237 op0
= TREE_OPERAND (op0
, 0);
3244 dump_generic_node (buffer
, op0
, 0, flags
, false);
3252 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3255 pretty_print_string (pretty_printer
*buffer
, const char *str
)
3265 pp_string (buffer
, "\\b");
3269 pp_string (buffer
, "\\f");
3273 pp_string (buffer
, "\\n");
3277 pp_string (buffer
, "\\r");
3281 pp_string (buffer
, "\\t");
3285 pp_string (buffer
, "\\v");
3289 pp_string (buffer
, "\\\\");
3293 pp_string (buffer
, "\\\"");
3297 pp_string (buffer
, "\\'");
3300 /* No need to handle \0; the loop terminates on \0. */
3303 pp_string (buffer
, "\\1");
3307 pp_string (buffer
, "\\2");
3311 pp_string (buffer
, "\\3");
3315 pp_string (buffer
, "\\4");
3319 pp_string (buffer
, "\\5");
3323 pp_string (buffer
, "\\6");
3327 pp_string (buffer
, "\\7");
3331 pp_character (buffer
, str
[0]);
3339 maybe_init_pretty_print (FILE *file
)
3343 new (&buffer
) pretty_printer ();
3344 pp_needs_newline (&buffer
) = true;
3345 pp_translate_identifiers (&buffer
) = false;
3349 buffer
.buffer
->stream
= file
;
3353 newline_and_indent (pretty_printer
*buffer
, int spc
)
3355 pp_newline (buffer
);
3359 /* Handle a %K format for TEXT. Separate from default_tree_printer so
3360 it can also be used in front ends.
3361 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3365 percent_K_format (text_info
*text
)
3367 tree t
= va_arg (*text
->args_ptr
, tree
), block
;
3368 gcc_assert (text
->locus
!= NULL
);
3369 *text
->locus
= EXPR_LOCATION (t
);
3370 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3371 block
= TREE_BLOCK (t
);
3372 *pp_ti_abstract_origin (text
) = NULL
;
3374 && TREE_CODE (block
) == BLOCK
3375 && BLOCK_ABSTRACT_ORIGIN (block
))
3377 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3379 while (TREE_CODE (ao
) == BLOCK
3380 && BLOCK_ABSTRACT_ORIGIN (ao
)
3381 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3382 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3384 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3386 *pp_ti_abstract_origin (text
) = block
;
3389 block
= BLOCK_SUPERCONTEXT (block
);
3393 /* Print the identifier ID to PRETTY-PRINTER. */
3396 pp_tree_identifier (pretty_printer
*pp
, tree id
)
3398 if (pp_translate_identifiers (pp
))
3400 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
3401 pp_append_text (pp
, text
, text
+ strlen (text
));
3404 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
3405 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
3408 /* A helper function that is used to dump function information before the
3412 dump_function_header (FILE *dump_file
, tree fdecl
, int flags
)
3414 const char *dname
, *aname
;
3415 struct cgraph_node
*node
= cgraph_get_node (fdecl
);
3416 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
3418 dname
= lang_hooks
.decl_printable_name (fdecl
, 2);
3420 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
3421 aname
= (IDENTIFIER_POINTER
3422 (DECL_ASSEMBLER_NAME (fdecl
)));
3424 aname
= "<unset-asm-name>";
3426 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
3427 dname
, aname
, fun
->funcdef_no
);
3428 if (!(flags
& TDF_NOUID
))
3429 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
3432 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
3433 node
->frequency
== NODE_FREQUENCY_HOT
3435 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
3436 ? " (unlikely executed)"
3437 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
3438 ? " (executed once)"
3442 fprintf (dump_file
, ")\n\n");
3445 /* Dump double_int D to pretty_printer PP. UNS is true
3446 if D is unsigned and false otherwise. */
3448 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
3451 pp_wide_integer (pp
, d
.low
);
3452 else if (d
.fits_uhwi ())
3453 pp_unsigned_wide_integer (pp
, d
.low
);
3456 unsigned HOST_WIDE_INT low
= d
.low
;
3457 HOST_WIDE_INT high
= d
.high
;
3458 if (!uns
&& d
.is_negative ())
3461 high
= ~high
+ !low
;
3464 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
3466 sprintf (pp_buffer (pp
)->digit_buffer
,
3467 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
3468 (unsigned HOST_WIDE_INT
) high
, low
);
3469 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);