1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2014 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"
30 #include "pointer-set.h"
31 #include "gimple-expr.h"
33 #include "langhooks.h"
34 #include "tree-iterator.h"
35 #include "tree-chrec.h"
37 #include "value-prof.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);
794 dump_upc_type_quals (pretty_printer
*buffer
, tree type
, int quals
)
796 gcc_assert (type
&& TYPE_CHECK (type
));
797 gcc_assert (quals
& TYPE_QUAL_SHARED
);
798 if (quals
& TYPE_QUAL_STRICT
)
799 pp_string (buffer
, "strict ");
800 if (quals
& TYPE_QUAL_RELAXED
)
801 pp_string (buffer
, "relaxed ");
802 pp_string (buffer
, "shared ");
803 if (TYPE_HAS_BLOCK_FACTOR (type
))
805 tree block_factor
= TYPE_BLOCK_FACTOR (type
);
806 pp_string (buffer
, "[");
807 pp_wide_integer (buffer
, TREE_INT_CST_LOW (block_factor
));
808 pp_string (buffer
, "] ");
812 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
813 indent. FLAGS specifies details to show in the dump (see TDF_* in
814 dumpfile.h). If IS_STMT is true, the object printed is considered
815 to be a statement and it is terminated by ';' if appropriate. */
818 dump_generic_node (pretty_printer
*buffer
, tree node
, int spc
, int flags
,
827 if (node
== NULL_TREE
)
830 is_expr
= EXPR_P (node
);
832 if (is_stmt
&& (flags
& TDF_STMTADDR
))
833 pp_printf (buffer
, "<&%p> ", (void *)node
);
835 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
836 dump_location (buffer
, EXPR_LOCATION (node
));
838 code
= TREE_CODE (node
);
842 pp_string (buffer
, "<<< error >>>");
845 case IDENTIFIER_NODE
:
846 pp_tree_identifier (buffer
, node
);
850 while (node
&& node
!= error_mark_node
)
852 if (TREE_PURPOSE (node
))
854 dump_generic_node (buffer
, TREE_PURPOSE (node
), spc
, flags
, false);
857 dump_generic_node (buffer
, TREE_VALUE (node
), spc
, flags
, false);
858 node
= TREE_CHAIN (node
);
859 if (node
&& TREE_CODE (node
) == TREE_LIST
)
868 dump_generic_node (buffer
, BINFO_TYPE (node
), spc
, flags
, false);
874 if (TREE_VEC_LENGTH (node
) > 0)
876 size_t len
= TREE_VEC_LENGTH (node
);
877 for (i
= 0; i
< len
- 1; i
++)
879 dump_generic_node (buffer
, TREE_VEC_ELT (node
, i
), spc
, flags
,
884 dump_generic_node (buffer
, TREE_VEC_ELT (node
, len
- 1), spc
,
893 case FIXED_POINT_TYPE
:
899 unsigned int quals
= TYPE_QUALS (node
);
900 enum tree_code_class tclass
;
902 if (quals
& TYPE_QUAL_ATOMIC
)
903 pp_string (buffer
, "atomic ");
904 if (quals
& TYPE_QUAL_CONST
)
905 pp_string (buffer
, "const ");
906 else if (quals
& TYPE_QUAL_VOLATILE
)
907 pp_string (buffer
, "volatile ");
908 else if (quals
& TYPE_QUAL_RESTRICT
)
909 pp_string (buffer
, "restrict ");
910 else if (quals
& TYPE_QUAL_SHARED
)
911 dump_upc_type_quals (buffer
, node
, quals
);
913 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
915 pp_string (buffer
, "<address-space-");
916 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
917 pp_string (buffer
, "> ");
920 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
922 if (tclass
== tcc_declaration
)
924 if (DECL_NAME (node
))
925 dump_decl_name (buffer
, node
, flags
);
927 pp_string (buffer
, "<unnamed type decl>");
929 else if (tclass
== tcc_type
)
931 if (TYPE_NAME (node
))
933 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
934 pp_tree_identifier (buffer
, TYPE_NAME (node
));
935 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
936 && DECL_NAME (TYPE_NAME (node
)))
937 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
939 pp_string (buffer
, "<unnamed type>");
941 else if (TREE_CODE (node
) == VECTOR_TYPE
)
943 pp_string (buffer
, "vector");
944 pp_left_paren (buffer
);
945 pp_wide_integer (buffer
, TYPE_VECTOR_SUBPARTS (node
));
946 pp_string (buffer
, ") ");
947 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
949 else if (TREE_CODE (node
) == INTEGER_TYPE
)
951 if (TYPE_PRECISION (node
) == CHAR_TYPE_SIZE
)
952 pp_string (buffer
, (TYPE_UNSIGNED (node
)
955 else if (TYPE_PRECISION (node
) == SHORT_TYPE_SIZE
)
956 pp_string (buffer
, (TYPE_UNSIGNED (node
)
959 else if (TYPE_PRECISION (node
) == INT_TYPE_SIZE
)
960 pp_string (buffer
, (TYPE_UNSIGNED (node
)
963 else if (TYPE_PRECISION (node
) == LONG_TYPE_SIZE
)
964 pp_string (buffer
, (TYPE_UNSIGNED (node
)
967 else if (TYPE_PRECISION (node
) == LONG_LONG_TYPE_SIZE
)
968 pp_string (buffer
, (TYPE_UNSIGNED (node
)
969 ? "unsigned long long"
970 : "signed long long"));
971 else if (TYPE_PRECISION (node
) >= CHAR_TYPE_SIZE
972 && exact_log2 (TYPE_PRECISION (node
)) != -1)
974 pp_string (buffer
, (TYPE_UNSIGNED (node
) ? "uint" : "int"));
975 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
976 pp_string (buffer
, "_t");
980 pp_string (buffer
, (TYPE_UNSIGNED (node
)
981 ? "<unnamed-unsigned:"
982 : "<unnamed-signed:"));
983 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
987 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
989 pp_string (buffer
, "__complex__ ");
990 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
992 else if (TREE_CODE (node
) == REAL_TYPE
)
994 pp_string (buffer
, "<float:");
995 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
998 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
1000 pp_string (buffer
, "<fixed-point-");
1001 pp_string (buffer
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
1002 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
1003 pp_greater (buffer
);
1005 else if (TREE_CODE (node
) == VOID_TYPE
)
1006 pp_string (buffer
, "void");
1008 pp_string (buffer
, "<unnamed type>");
1014 case REFERENCE_TYPE
:
1015 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
1017 if (TREE_TYPE (node
) == NULL
)
1019 pp_string (buffer
, str
);
1020 pp_string (buffer
, "<null type>");
1022 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
1024 tree fnode
= TREE_TYPE (node
);
1026 dump_generic_node (buffer
, TREE_TYPE (fnode
), spc
, flags
, false);
1028 pp_left_paren (buffer
);
1029 pp_string (buffer
, str
);
1030 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1031 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
1032 else if (flags
& TDF_NOUID
)
1033 pp_printf (buffer
, "<Txxxx>");
1035 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
1037 pp_right_paren (buffer
);
1038 dump_function_declaration (buffer
, fnode
, spc
, flags
);
1042 unsigned int quals
= TYPE_QUALS (node
);
1044 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1046 pp_string (buffer
, str
);
1048 if (quals
& TYPE_QUAL_CONST
)
1049 pp_string (buffer
, " const");
1050 if (quals
& TYPE_QUAL_VOLATILE
)
1051 pp_string (buffer
, " volatile");
1052 if (quals
& TYPE_QUAL_RESTRICT
)
1053 pp_string (buffer
, " restrict");
1054 if (quals
& TYPE_QUAL_SHARED
)
1056 if (quals
& TYPE_QUAL_STRICT
)
1057 pp_string (buffer
, " strict");
1058 if (quals
& TYPE_QUAL_RELAXED
)
1059 pp_string (buffer
, " relaxed");
1060 pp_string (buffer
, " shared");
1063 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
1065 pp_string (buffer
, " <address-space-");
1066 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
1067 pp_greater (buffer
);
1070 if (TYPE_REF_CAN_ALIAS_ALL (node
))
1071 pp_string (buffer
, " {ref-all}");
1081 if (integer_zerop (TREE_OPERAND (node
, 1))
1082 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1083 infer them and MEM_ATTR caching will share MEM_REFs
1084 with differently-typed op0s. */
1085 && TREE_CODE (TREE_OPERAND (node
, 0)) != INTEGER_CST
1086 /* Released SSA_NAMES have no TREE_TYPE. */
1087 && TREE_TYPE (TREE_OPERAND (node
, 0)) != NULL_TREE
1088 /* Same pointer types, but ignoring POINTER_TYPE vs.
1090 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1091 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1092 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 0)))
1093 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node
, 1))))
1094 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 0)))
1095 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node
, 1))))
1096 /* Same value types ignoring qualifiers. */
1097 && (TYPE_MAIN_VARIANT (TREE_TYPE (node
))
1098 == TYPE_MAIN_VARIANT
1099 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node
, 1))))))
1101 if (TREE_CODE (TREE_OPERAND (node
, 0)) != ADDR_EXPR
)
1104 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1108 dump_generic_node (buffer
,
1109 TREE_OPERAND (TREE_OPERAND (node
, 0), 0),
1116 pp_string (buffer
, "MEM[");
1117 pp_left_paren (buffer
);
1118 ptype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node
, 1)));
1119 dump_generic_node (buffer
, ptype
,
1120 spc
, flags
| TDF_SLIM
, false);
1121 pp_right_paren (buffer
);
1122 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1124 if (!integer_zerop (TREE_OPERAND (node
, 1)))
1126 pp_string (buffer
, " + ");
1127 dump_generic_node (buffer
, TREE_OPERAND (node
, 1),
1130 pp_right_bracket (buffer
);
1135 case TARGET_MEM_REF
:
1137 const char *sep
= "";
1140 pp_string (buffer
, "MEM[");
1142 if (TREE_CODE (TMR_BASE (node
)) == ADDR_EXPR
)
1144 pp_string (buffer
, sep
);
1146 pp_string (buffer
, "symbol: ");
1147 dump_generic_node (buffer
, TREE_OPERAND (TMR_BASE (node
), 0),
1152 pp_string (buffer
, sep
);
1154 pp_string (buffer
, "base: ");
1155 dump_generic_node (buffer
, TMR_BASE (node
), spc
, flags
, false);
1157 tmp
= TMR_INDEX2 (node
);
1160 pp_string (buffer
, sep
);
1162 pp_string (buffer
, "base: ");
1163 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1165 tmp
= TMR_INDEX (node
);
1168 pp_string (buffer
, sep
);
1170 pp_string (buffer
, "index: ");
1171 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1173 tmp
= TMR_STEP (node
);
1176 pp_string (buffer
, sep
);
1178 pp_string (buffer
, "step: ");
1179 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1181 tmp
= TMR_OFFSET (node
);
1184 pp_string (buffer
, sep
);
1186 pp_string (buffer
, "offset: ");
1187 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1189 pp_right_bracket (buffer
);
1197 /* Print the innermost component type. */
1198 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
1199 tmp
= TREE_TYPE (tmp
))
1201 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
1203 /* Print the dimensions. */
1204 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
1205 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
1211 case QUAL_UNION_TYPE
:
1213 unsigned int quals
= TYPE_QUALS (node
);
1215 if (quals
& TYPE_QUAL_ATOMIC
)
1216 pp_string (buffer
, "atomic ");
1217 if (quals
& TYPE_QUAL_CONST
)
1218 pp_string (buffer
, "const ");
1219 if (quals
& TYPE_QUAL_VOLATILE
)
1220 pp_string (buffer
, "volatile ");
1221 if (quals
& TYPE_QUAL_SHARED
)
1222 dump_upc_type_quals (buffer
, node
, quals
);
1224 /* Print the name of the structure. */
1225 if (TREE_CODE (node
) == RECORD_TYPE
)
1226 pp_string (buffer
, "struct ");
1227 else if (TREE_CODE (node
) == UNION_TYPE
)
1228 pp_string (buffer
, "union ");
1230 if (upc_pts_rep_type_node
&& node
== upc_pts_rep_type_node
)
1231 /* Normally, builtin types will not be printed.
1232 We short-circuit that check for the UPC "struct PTS"
1233 representation type. */
1234 pp_string (buffer
, "upc_shared_ptr_t");
1235 else if (TYPE_NAME (node
))
1236 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, flags
, false);
1237 else if (!(flags
& TDF_SLIM
))
1238 /* FIXME: If we eliminate the 'else' above and attempt
1239 to show the fields for named types, we may get stuck
1240 following a cycle of pointers to structs. The alleged
1241 self-reference check in print_struct_decl will not detect
1242 cycles involving more than one pointer or struct type. */
1243 print_struct_decl (buffer
, node
, spc
, flags
);
1252 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
1254 /* In the case of a pointer, one may want to divide by the
1255 size of the pointed-to type. Unfortunately, this not
1256 straightforward. The C front-end maps expressions
1261 in such a way that the two INTEGER_CST nodes for "5" have
1262 different values but identical types. In the latter
1263 case, the 5 is multiplied by sizeof (int) in c-common.c
1264 (pointer_int_sum) to convert it to a byte address, and
1265 yet the type of the node is left unchanged. Argh. What
1266 is consistent though is that the number value corresponds
1267 to bytes (UNITS) offset.
1269 NB: Neither of the following divisors can be trivially
1270 used to recover the original literal:
1272 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1273 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1274 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
1275 pp_string (buffer
, "B"); /* pseudo-unit */
1278 pp_double_int (buffer
, tree_to_double_int (node
),
1279 TYPE_UNSIGNED (TREE_TYPE (node
)));
1280 if (TREE_OVERFLOW (node
))
1281 pp_string (buffer
, "(OVF)");
1285 /* Code copied from print_node. */
1288 if (TREE_OVERFLOW (node
))
1289 pp_string (buffer
, " overflow");
1291 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
1292 d
= TREE_REAL_CST (node
);
1293 if (REAL_VALUE_ISINF (d
))
1294 pp_string (buffer
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
1295 else if (REAL_VALUE_ISNAN (d
))
1296 pp_string (buffer
, " Nan");
1300 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
1301 pp_string (buffer
, string
);
1306 unsigned char *p
= (unsigned char *) &TREE_REAL_CST (node
);
1307 pp_string (buffer
, "0x");
1308 for (i
= 0; i
< sizeof TREE_REAL_CST (node
); i
++)
1309 output_formatted_integer (buffer
, "%02x", *p
++);
1318 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
1319 pp_string (buffer
, string
);
1324 pp_string (buffer
, "__complex__ (");
1325 dump_generic_node (buffer
, TREE_REALPART (node
), spc
, flags
, false);
1326 pp_string (buffer
, ", ");
1327 dump_generic_node (buffer
, TREE_IMAGPART (node
), spc
, flags
, false);
1328 pp_right_paren (buffer
);
1332 pp_string (buffer
, "\"");
1333 pretty_print_string (buffer
, TREE_STRING_POINTER (node
));
1334 pp_string (buffer
, "\"");
1340 pp_string (buffer
, "{ ");
1341 for (i
= 0; i
< VECTOR_CST_NELTS (node
); ++i
)
1344 pp_string (buffer
, ", ");
1345 dump_generic_node (buffer
, VECTOR_CST_ELT (node
, i
),
1348 pp_string (buffer
, " }");
1354 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1356 if (TREE_CODE (node
) == METHOD_TYPE
)
1358 if (TYPE_METHOD_BASETYPE (node
))
1359 dump_decl_name (buffer
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1362 pp_string (buffer
, "<null method basetype>");
1363 pp_colon_colon (buffer
);
1365 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1366 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
1367 else if (flags
& TDF_NOUID
)
1368 pp_printf (buffer
, "<Txxxx>");
1370 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
1371 dump_function_declaration (buffer
, node
, spc
, flags
);
1376 dump_decl_name (buffer
, node
, flags
);
1380 if (DECL_NAME (node
))
1381 dump_decl_name (buffer
, node
, flags
);
1382 else if (LABEL_DECL_UID (node
) != -1)
1383 pp_printf (buffer
, "<L%d>", (int) LABEL_DECL_UID (node
));
1386 if (flags
& TDF_NOUID
)
1387 pp_string (buffer
, "<D.xxxx>");
1389 pp_printf (buffer
, "<D.%u>", DECL_UID (node
));
1394 if (DECL_IS_BUILTIN (node
))
1396 /* Don't print the declaration of built-in types. */
1399 if (DECL_NAME (node
))
1400 dump_decl_name (buffer
, node
, flags
);
1401 else if (TYPE_NAME (TREE_TYPE (node
)) != node
)
1403 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1404 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1405 && TYPE_METHODS (TREE_TYPE (node
)))
1407 /* The type is a c++ class: all structures have at least
1409 pp_string (buffer
, "class ");
1410 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1415 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1416 ? "union" : "struct "));
1417 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1421 pp_string (buffer
, "<anon>");
1427 case DEBUG_EXPR_DECL
:
1428 case NAMESPACE_DECL
:
1430 dump_decl_name (buffer
, node
, flags
);
1434 pp_string (buffer
, "<retval>");
1438 op0
= TREE_OPERAND (node
, 0);
1441 && (TREE_CODE (op0
) == INDIRECT_REF
1442 || (TREE_CODE (op0
) == MEM_REF
1443 && TREE_CODE (TREE_OPERAND (op0
, 0)) != ADDR_EXPR
1444 && integer_zerop (TREE_OPERAND (op0
, 1))
1445 /* Dump the types of INTEGER_CSTs explicitly, for we
1446 can't infer them and MEM_ATTR caching will share
1447 MEM_REFs with differently-typed op0s. */
1448 && TREE_CODE (TREE_OPERAND (op0
, 0)) != INTEGER_CST
1449 /* Released SSA_NAMES have no TREE_TYPE. */
1450 && TREE_TYPE (TREE_OPERAND (op0
, 0)) != NULL_TREE
1451 /* Same pointer types, but ignoring POINTER_TYPE vs.
1453 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1454 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1455 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1456 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1457 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 0)))
1458 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0
, 1))))
1459 /* Same value types ignoring qualifiers. */
1460 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0
))
1461 == TYPE_MAIN_VARIANT
1462 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0
, 1))))))))
1464 op0
= TREE_OPERAND (op0
, 0);
1467 if (op_prio (op0
) < op_prio (node
))
1468 pp_left_paren (buffer
);
1469 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1470 if (op_prio (op0
) < op_prio (node
))
1471 pp_right_paren (buffer
);
1472 pp_string (buffer
, str
);
1473 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1474 op0
= component_ref_field_offset (node
);
1475 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1477 pp_string (buffer
, "{off: ");
1478 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1479 pp_right_brace (buffer
);
1484 pp_string (buffer
, "BIT_FIELD_REF <");
1485 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1486 pp_string (buffer
, ", ");
1487 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1488 pp_string (buffer
, ", ");
1489 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1490 pp_greater (buffer
);
1494 case ARRAY_RANGE_REF
:
1495 op0
= TREE_OPERAND (node
, 0);
1496 if (op_prio (op0
) < op_prio (node
))
1497 pp_left_paren (buffer
);
1498 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1499 if (op_prio (op0
) < op_prio (node
))
1500 pp_right_paren (buffer
);
1501 pp_left_bracket (buffer
);
1502 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1503 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1504 pp_string (buffer
, " ...");
1505 pp_right_bracket (buffer
);
1507 op0
= array_ref_low_bound (node
);
1508 op1
= array_ref_element_size (node
);
1510 if (!integer_zerop (op0
)
1511 || TREE_OPERAND (node
, 2)
1512 || TREE_OPERAND (node
, 3))
1514 pp_string (buffer
, "{lb: ");
1515 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1516 pp_string (buffer
, " sz: ");
1517 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1518 pp_right_brace (buffer
);
1524 unsigned HOST_WIDE_INT ix
;
1526 bool is_struct_init
= false;
1527 bool is_array_init
= false;
1528 double_int curidx
= double_int_zero
;
1529 pp_left_brace (buffer
);
1530 if (TREE_CLOBBER_P (node
))
1531 pp_string (buffer
, "CLOBBER");
1532 else if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1533 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1534 is_struct_init
= true;
1535 else if (TREE_CODE (TREE_TYPE (node
)) == ARRAY_TYPE
1536 && TYPE_DOMAIN (TREE_TYPE (node
))
1537 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)))
1538 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
))))
1541 tree minv
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node
)));
1542 is_array_init
= true;
1543 curidx
= tree_to_double_int (minv
);
1545 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1552 dump_generic_node (buffer
, field
, spc
, flags
, false);
1555 else if (is_array_init
1556 && (TREE_CODE (field
) != INTEGER_CST
1557 || tree_to_double_int (field
) != curidx
))
1559 pp_left_bracket (buffer
);
1560 if (TREE_CODE (field
) == RANGE_EXPR
)
1562 dump_generic_node (buffer
, TREE_OPERAND (field
, 0), spc
,
1564 pp_string (buffer
, " ... ");
1565 dump_generic_node (buffer
, TREE_OPERAND (field
, 1), spc
,
1567 if (TREE_CODE (TREE_OPERAND (field
, 1)) == INTEGER_CST
)
1568 curidx
= tree_to_double_int (TREE_OPERAND (field
, 1));
1571 dump_generic_node (buffer
, field
, spc
, flags
, false);
1572 if (TREE_CODE (field
) == INTEGER_CST
)
1573 curidx
= tree_to_double_int (field
);
1574 pp_string (buffer
, "]=");
1578 curidx
+= double_int_one
;
1579 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1580 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1581 val
= TREE_OPERAND (val
, 0);
1582 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1583 dump_decl_name (buffer
, val
, flags
);
1585 dump_generic_node (buffer
, val
, spc
, flags
, false);
1586 if (ix
!= vec_safe_length (CONSTRUCTOR_ELTS (node
)) - 1)
1592 pp_right_brace (buffer
);
1599 if (flags
& TDF_SLIM
)
1601 pp_string (buffer
, "<COMPOUND_EXPR>");
1605 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1606 spc
, flags
, !(flags
& TDF_SLIM
));
1607 if (flags
& TDF_SLIM
)
1608 newline_and_indent (buffer
, spc
);
1615 for (tp
= &TREE_OPERAND (node
, 1);
1616 TREE_CODE (*tp
) == COMPOUND_EXPR
;
1617 tp
= &TREE_OPERAND (*tp
, 1))
1619 dump_generic_node (buffer
, TREE_OPERAND (*tp
, 0),
1620 spc
, flags
, !(flags
& TDF_SLIM
));
1621 if (flags
& TDF_SLIM
)
1622 newline_and_indent (buffer
, spc
);
1630 dump_generic_node (buffer
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
1634 case STATEMENT_LIST
:
1636 tree_stmt_iterator si
;
1639 if (flags
& TDF_SLIM
)
1641 pp_string (buffer
, "<STATEMENT_LIST>");
1645 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
1648 newline_and_indent (buffer
, spc
);
1651 dump_generic_node (buffer
, tsi_stmt (si
), spc
, flags
, true);
1658 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
,
1663 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
,
1668 pp_string (buffer
, "TARGET_EXPR <");
1669 dump_generic_node (buffer
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
1672 dump_generic_node (buffer
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
1673 pp_greater (buffer
);
1677 print_declaration (buffer
, DECL_EXPR_DECL (node
), spc
, flags
);
1682 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
1684 pp_string (buffer
, "if (");
1685 dump_generic_node (buffer
, COND_EXPR_COND (node
), spc
, flags
, false);
1686 pp_right_paren (buffer
);
1687 /* The lowered cond_exprs should always be printed in full. */
1688 if (COND_EXPR_THEN (node
)
1689 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
1690 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
1691 && COND_EXPR_ELSE (node
)
1692 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
1693 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
1696 dump_generic_node (buffer
, COND_EXPR_THEN (node
),
1698 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1700 pp_string (buffer
, " else ");
1701 dump_generic_node (buffer
, COND_EXPR_ELSE (node
),
1705 else if (!(flags
& TDF_SLIM
))
1707 /* Output COND_EXPR_THEN. */
1708 if (COND_EXPR_THEN (node
))
1710 newline_and_indent (buffer
, spc
+2);
1711 pp_left_brace (buffer
);
1712 newline_and_indent (buffer
, spc
+4);
1713 dump_generic_node (buffer
, COND_EXPR_THEN (node
), spc
+4,
1715 newline_and_indent (buffer
, spc
+2);
1716 pp_right_brace (buffer
);
1719 /* Output COND_EXPR_ELSE. */
1720 if (COND_EXPR_ELSE (node
)
1721 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1723 newline_and_indent (buffer
, spc
);
1724 pp_string (buffer
, "else");
1725 newline_and_indent (buffer
, spc
+2);
1726 pp_left_brace (buffer
);
1727 newline_and_indent (buffer
, spc
+4);
1728 dump_generic_node (buffer
, COND_EXPR_ELSE (node
), spc
+4,
1730 newline_and_indent (buffer
, spc
+2);
1731 pp_right_brace (buffer
);
1738 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1740 pp_question (buffer
);
1742 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1746 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1751 pp_left_brace (buffer
);
1752 if (!(flags
& TDF_SLIM
))
1754 if (BIND_EXPR_VARS (node
))
1756 pp_newline (buffer
);
1758 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= DECL_CHAIN (op0
))
1760 print_declaration (buffer
, op0
, spc
+2, flags
);
1761 pp_newline (buffer
);
1765 newline_and_indent (buffer
, spc
+2);
1766 dump_generic_node (buffer
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
1767 newline_and_indent (buffer
, spc
);
1768 pp_right_brace (buffer
);
1774 print_call_name (buffer
, CALL_EXPR_FN (node
), flags
);
1776 /* Print parameters. */
1778 pp_left_paren (buffer
);
1781 call_expr_arg_iterator iter
;
1782 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
1784 dump_generic_node (buffer
, arg
, spc
, flags
, false);
1785 if (more_call_expr_args_p (&iter
))
1792 if (CALL_EXPR_VA_ARG_PACK (node
))
1794 if (call_expr_nargs (node
) > 0)
1799 pp_string (buffer
, "__builtin_va_arg_pack ()");
1801 pp_right_paren (buffer
);
1803 op1
= CALL_EXPR_STATIC_CHAIN (node
);
1806 pp_string (buffer
, " [static-chain: ");
1807 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1808 pp_right_bracket (buffer
);
1811 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
1812 pp_string (buffer
, " [return slot optimization]");
1813 if (CALL_EXPR_TAILCALL (node
))
1814 pp_string (buffer
, " [tail call]");
1817 case WITH_CLEANUP_EXPR
:
1821 case CLEANUP_POINT_EXPR
:
1822 pp_string (buffer
, "<<cleanup_point ");
1823 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1824 pp_string (buffer
, ">>");
1827 case PLACEHOLDER_EXPR
:
1828 pp_string (buffer
, "<PLACEHOLDER_EXPR ");
1829 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1830 pp_greater (buffer
);
1833 /* Binary arithmetic and logic expressions. */
1834 case WIDEN_SUM_EXPR
:
1835 case WIDEN_MULT_EXPR
:
1837 case MULT_HIGHPART_EXPR
:
1839 case POINTER_PLUS_EXPR
:
1841 case TRUNC_DIV_EXPR
:
1843 case FLOOR_DIV_EXPR
:
1844 case ROUND_DIV_EXPR
:
1845 case TRUNC_MOD_EXPR
:
1847 case FLOOR_MOD_EXPR
:
1848 case ROUND_MOD_EXPR
:
1850 case EXACT_DIV_EXPR
:
1855 case VEC_LSHIFT_EXPR
:
1856 case VEC_RSHIFT_EXPR
:
1857 case WIDEN_LSHIFT_EXPR
:
1861 case TRUTH_ANDIF_EXPR
:
1862 case TRUTH_ORIF_EXPR
:
1863 case TRUTH_AND_EXPR
:
1865 case TRUTH_XOR_EXPR
:
1879 case UNORDERED_EXPR
:
1881 const char *op
= op_symbol (node
);
1882 op0
= TREE_OPERAND (node
, 0);
1883 op1
= TREE_OPERAND (node
, 1);
1885 /* When the operands are expressions with less priority,
1886 keep semantics of the tree representation. */
1887 if (op_prio (op0
) <= op_prio (node
))
1889 pp_left_paren (buffer
);
1890 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1891 pp_right_paren (buffer
);
1894 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1897 pp_string (buffer
, op
);
1900 /* When the operands are expressions with less priority,
1901 keep semantics of the tree representation. */
1902 if (op_prio (op1
) <= op_prio (node
))
1904 pp_left_paren (buffer
);
1905 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1906 pp_right_paren (buffer
);
1909 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1913 /* Unary arithmetic and logic expressions. */
1916 case TRUTH_NOT_EXPR
:
1918 case PREDECREMENT_EXPR
:
1919 case PREINCREMENT_EXPR
:
1921 if (TREE_CODE (node
) == ADDR_EXPR
1922 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
1923 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
1924 ; /* Do not output '&' for strings and function pointers. */
1926 pp_string (buffer
, op_symbol (node
));
1928 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1930 pp_left_paren (buffer
);
1931 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1932 pp_right_paren (buffer
);
1935 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1938 case POSTDECREMENT_EXPR
:
1939 case POSTINCREMENT_EXPR
:
1940 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1942 pp_left_paren (buffer
);
1943 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1944 pp_right_paren (buffer
);
1947 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1948 pp_string (buffer
, op_symbol (node
));
1952 pp_string (buffer
, "MIN_EXPR <");
1953 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1954 pp_string (buffer
, ", ");
1955 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1956 pp_greater (buffer
);
1960 pp_string (buffer
, "MAX_EXPR <");
1961 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1962 pp_string (buffer
, ", ");
1963 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1964 pp_greater (buffer
);
1968 pp_string (buffer
, "ABS_EXPR <");
1969 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1970 pp_greater (buffer
);
1977 case ADDR_SPACE_CONVERT_EXPR
:
1978 case FIXED_CONVERT_EXPR
:
1979 case FIX_TRUNC_EXPR
:
1982 type
= TREE_TYPE (node
);
1983 op0
= TREE_OPERAND (node
, 0);
1984 if (type
!= TREE_TYPE (op0
))
1986 pp_left_paren (buffer
);
1987 dump_generic_node (buffer
, type
, spc
, flags
, false);
1988 pp_string (buffer
, ") ");
1990 if (op_prio (op0
) < op_prio (node
))
1991 pp_left_paren (buffer
);
1992 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1993 if (op_prio (op0
) < op_prio (node
))
1994 pp_right_paren (buffer
);
1997 case VIEW_CONVERT_EXPR
:
1998 pp_string (buffer
, "VIEW_CONVERT_EXPR<");
1999 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
2000 pp_string (buffer
, ">(");
2001 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2002 pp_right_paren (buffer
);
2006 pp_string (buffer
, "((");
2007 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2008 pp_string (buffer
, "))");
2011 case NON_LVALUE_EXPR
:
2012 pp_string (buffer
, "NON_LVALUE_EXPR <");
2013 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2014 pp_greater (buffer
);
2018 pp_string (buffer
, "SAVE_EXPR <");
2019 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2020 pp_greater (buffer
);
2024 pp_string (buffer
, "COMPLEX_EXPR <");
2025 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2026 pp_string (buffer
, ", ");
2027 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2028 pp_greater (buffer
);
2032 pp_string (buffer
, "CONJ_EXPR <");
2033 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2034 pp_greater (buffer
);
2038 pp_string (buffer
, "REALPART_EXPR <");
2039 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2040 pp_greater (buffer
);
2044 pp_string (buffer
, "IMAGPART_EXPR <");
2045 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2046 pp_greater (buffer
);
2050 pp_string (buffer
, "VA_ARG_EXPR <");
2051 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2052 pp_greater (buffer
);
2055 case TRY_FINALLY_EXPR
:
2056 case TRY_CATCH_EXPR
:
2057 pp_string (buffer
, "try");
2058 newline_and_indent (buffer
, spc
+2);
2059 pp_left_brace (buffer
);
2060 newline_and_indent (buffer
, spc
+4);
2061 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
2062 newline_and_indent (buffer
, spc
+2);
2063 pp_right_brace (buffer
);
2064 newline_and_indent (buffer
, spc
);
2066 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
2067 newline_and_indent (buffer
, spc
+2);
2068 pp_left_brace (buffer
);
2069 newline_and_indent (buffer
, spc
+4);
2070 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
2071 newline_and_indent (buffer
, spc
+2);
2072 pp_right_brace (buffer
);
2077 pp_string (buffer
, "catch (");
2078 dump_generic_node (buffer
, CATCH_TYPES (node
), spc
+2, flags
, false);
2079 pp_right_paren (buffer
);
2080 newline_and_indent (buffer
, spc
+2);
2081 pp_left_brace (buffer
);
2082 newline_and_indent (buffer
, spc
+4);
2083 dump_generic_node (buffer
, CATCH_BODY (node
), spc
+4, flags
, true);
2084 newline_and_indent (buffer
, spc
+2);
2085 pp_right_brace (buffer
);
2089 case EH_FILTER_EXPR
:
2090 pp_string (buffer
, "<<<eh_filter (");
2091 dump_generic_node (buffer
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
2092 pp_string (buffer
, ")>>>");
2093 newline_and_indent (buffer
, spc
+2);
2094 pp_left_brace (buffer
);
2095 newline_and_indent (buffer
, spc
+4);
2096 dump_generic_node (buffer
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
2097 newline_and_indent (buffer
, spc
+2);
2098 pp_right_brace (buffer
);
2103 op0
= TREE_OPERAND (node
, 0);
2104 /* If this is for break or continue, don't bother printing it. */
2105 if (DECL_NAME (op0
))
2107 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2108 if (strcmp (name
, "break") == 0
2109 || strcmp (name
, "continue") == 0)
2112 dump_generic_node (buffer
, op0
, spc
, flags
, false);
2114 if (DECL_NONLOCAL (op0
))
2115 pp_string (buffer
, " [non-local]");
2119 pp_string (buffer
, "while (1)");
2120 if (!(flags
& TDF_SLIM
))
2122 newline_and_indent (buffer
, spc
+2);
2123 pp_left_brace (buffer
);
2124 newline_and_indent (buffer
, spc
+4);
2125 dump_generic_node (buffer
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
2126 newline_and_indent (buffer
, spc
+2);
2127 pp_right_brace (buffer
);
2133 pp_string (buffer
, "// predicted ");
2134 if (PREDICT_EXPR_OUTCOME (node
))
2135 pp_string (buffer
, "likely by ");
2137 pp_string (buffer
, "unlikely by ");
2138 pp_string (buffer
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
2139 pp_string (buffer
, " predictor.");
2143 pp_string (buffer
, "ANNOTATE_EXPR <");
2144 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (node
, 1)))
2146 case annot_expr_ivdep_kind
:
2147 pp_string (buffer
, "ivdep, ");
2150 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2151 pp_greater (buffer
);
2155 pp_string (buffer
, "return");
2156 op0
= TREE_OPERAND (node
, 0);
2160 if (TREE_CODE (op0
) == MODIFY_EXPR
)
2161 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1),
2164 dump_generic_node (buffer
, op0
, spc
, flags
, false);
2169 pp_string (buffer
, "if (");
2170 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2171 pp_string (buffer
, ") break");
2175 pp_string (buffer
, "switch (");
2176 dump_generic_node (buffer
, SWITCH_COND (node
), spc
, flags
, false);
2177 pp_right_paren (buffer
);
2178 if (!(flags
& TDF_SLIM
))
2180 newline_and_indent (buffer
, spc
+2);
2181 pp_left_brace (buffer
);
2182 if (SWITCH_BODY (node
))
2184 newline_and_indent (buffer
, spc
+4);
2185 dump_generic_node (buffer
, SWITCH_BODY (node
), spc
+4, flags
,
2190 tree vec
= SWITCH_LABELS (node
);
2191 size_t i
, n
= TREE_VEC_LENGTH (vec
);
2192 for (i
= 0; i
< n
; ++i
)
2194 tree elt
= TREE_VEC_ELT (vec
, i
);
2195 newline_and_indent (buffer
, spc
+4);
2198 dump_generic_node (buffer
, elt
, spc
+4, flags
, false);
2199 pp_string (buffer
, " goto ");
2200 dump_generic_node (buffer
, CASE_LABEL (elt
), spc
+4,
2202 pp_semicolon (buffer
);
2205 pp_string (buffer
, "case ???: goto ???;");
2208 newline_and_indent (buffer
, spc
+2);
2209 pp_right_brace (buffer
);
2215 op0
= GOTO_DESTINATION (node
);
2216 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
2218 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
2219 if (strcmp (name
, "break") == 0
2220 || strcmp (name
, "continue") == 0)
2222 pp_string (buffer
, name
);
2226 pp_string (buffer
, "goto ");
2227 dump_generic_node (buffer
, op0
, spc
, flags
, false);
2231 pp_string (buffer
, "__asm__");
2232 if (ASM_VOLATILE_P (node
))
2233 pp_string (buffer
, " __volatile__");
2234 pp_left_paren (buffer
);
2235 dump_generic_node (buffer
, ASM_STRING (node
), spc
, flags
, false);
2237 dump_generic_node (buffer
, ASM_OUTPUTS (node
), spc
, flags
, false);
2239 dump_generic_node (buffer
, ASM_INPUTS (node
), spc
, flags
, false);
2240 if (ASM_CLOBBERS (node
))
2243 dump_generic_node (buffer
, ASM_CLOBBERS (node
), spc
, flags
, false);
2245 pp_right_paren (buffer
);
2248 case CASE_LABEL_EXPR
:
2249 if (CASE_LOW (node
) && CASE_HIGH (node
))
2251 pp_string (buffer
, "case ");
2252 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
2253 pp_string (buffer
, " ... ");
2254 dump_generic_node (buffer
, CASE_HIGH (node
), spc
, flags
, false);
2256 else if (CASE_LOW (node
))
2258 pp_string (buffer
, "case ");
2259 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
2262 pp_string (buffer
, "default");
2267 pp_string (buffer
, "OBJ_TYPE_REF(");
2268 dump_generic_node (buffer
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
2269 pp_semicolon (buffer
);
2270 if (!(flags
& TDF_SLIM
) && virtual_method_call_p (node
))
2272 pp_string (buffer
, "(");
2273 dump_generic_node (buffer
, obj_type_ref_class (node
), spc
, flags
, false);
2274 pp_string (buffer
, ")");
2276 dump_generic_node (buffer
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
2278 dump_generic_node (buffer
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
2279 pp_right_paren (buffer
);
2283 if (SSA_NAME_IDENTIFIER (node
))
2284 dump_generic_node (buffer
, SSA_NAME_IDENTIFIER (node
),
2286 pp_underscore (buffer
);
2287 pp_decimal_int (buffer
, SSA_NAME_VERSION (node
));
2288 if (SSA_NAME_IS_DEFAULT_DEF (node
))
2289 pp_string (buffer
, "(D)");
2290 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
2291 pp_string (buffer
, "(ab)");
2294 case WITH_SIZE_EXPR
:
2295 pp_string (buffer
, "WITH_SIZE_EXPR <");
2296 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2297 pp_string (buffer
, ", ");
2298 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2299 pp_greater (buffer
);
2303 pp_string (buffer
, "ASSERT_EXPR <");
2304 dump_generic_node (buffer
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
2305 pp_string (buffer
, ", ");
2306 dump_generic_node (buffer
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
2307 pp_greater (buffer
);
2311 pp_string (buffer
, "scev_known");
2314 case SCEV_NOT_KNOWN
:
2315 pp_string (buffer
, "scev_not_known");
2318 case POLYNOMIAL_CHREC
:
2319 pp_left_brace (buffer
);
2320 dump_generic_node (buffer
, CHREC_LEFT (node
), spc
, flags
, false);
2321 pp_string (buffer
, ", +, ");
2322 dump_generic_node (buffer
, CHREC_RIGHT (node
), spc
, flags
, false);
2323 pp_string (buffer
, "}_");
2324 dump_generic_node (buffer
, CHREC_VAR (node
), spc
, flags
, false);
2328 case REALIGN_LOAD_EXPR
:
2329 pp_string (buffer
, "REALIGN_LOAD <");
2330 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2331 pp_string (buffer
, ", ");
2332 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2333 pp_string (buffer
, ", ");
2334 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2335 pp_greater (buffer
);
2339 pp_string (buffer
, " VEC_COND_EXPR < ");
2340 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2341 pp_string (buffer
, " , ");
2342 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2343 pp_string (buffer
, " , ");
2344 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2345 pp_string (buffer
, " > ");
2349 pp_string (buffer
, " VEC_PERM_EXPR < ");
2350 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2351 pp_string (buffer
, " , ");
2352 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2353 pp_string (buffer
, " , ");
2354 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2355 pp_string (buffer
, " > ");
2359 pp_string (buffer
, " DOT_PROD_EXPR < ");
2360 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2361 pp_string (buffer
, ", ");
2362 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2363 pp_string (buffer
, ", ");
2364 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2365 pp_string (buffer
, " > ");
2368 case WIDEN_MULT_PLUS_EXPR
:
2369 pp_string (buffer
, " WIDEN_MULT_PLUS_EXPR < ");
2370 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2371 pp_string (buffer
, ", ");
2372 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2373 pp_string (buffer
, ", ");
2374 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2375 pp_string (buffer
, " > ");
2378 case WIDEN_MULT_MINUS_EXPR
:
2379 pp_string (buffer
, " WIDEN_MULT_MINUS_EXPR < ");
2380 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2381 pp_string (buffer
, ", ");
2382 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2383 pp_string (buffer
, ", ");
2384 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2385 pp_string (buffer
, " > ");
2389 pp_string (buffer
, " FMA_EXPR < ");
2390 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2391 pp_string (buffer
, ", ");
2392 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2393 pp_string (buffer
, ", ");
2394 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
2395 pp_string (buffer
, " > ");
2399 pp_string (buffer
, "#pragma omp parallel");
2400 dump_omp_clauses (buffer
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
2403 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
2405 newline_and_indent (buffer
, spc
+ 2);
2406 pp_left_brace (buffer
);
2407 newline_and_indent (buffer
, spc
+ 4);
2408 dump_generic_node (buffer
, OMP_BODY (node
), spc
+ 4, flags
, false);
2409 newline_and_indent (buffer
, spc
+ 2);
2410 pp_right_brace (buffer
);
2416 pp_string (buffer
, "#pragma omp task");
2417 dump_omp_clauses (buffer
, OMP_TASK_CLAUSES (node
), spc
, flags
);
2421 pp_string (buffer
, "#pragma omp for");
2425 pp_string (buffer
, "#pragma omp simd");
2429 pp_string (buffer
, "#pragma simd");
2432 case OMP_DISTRIBUTE
:
2433 pp_string (buffer
, "#pragma omp distribute");
2437 pp_string (buffer
, "#pragma omp teams");
2438 dump_omp_clauses (buffer
, OMP_TEAMS_CLAUSES (node
), spc
, flags
);
2441 case OMP_TARGET_DATA
:
2442 pp_string (buffer
, "#pragma omp target data");
2443 dump_omp_clauses (buffer
, OMP_TARGET_DATA_CLAUSES (node
), spc
, flags
);
2447 pp_string (buffer
, "#pragma omp target");
2448 dump_omp_clauses (buffer
, OMP_TARGET_CLAUSES (node
), spc
, flags
);
2451 case OMP_TARGET_UPDATE
:
2452 pp_string (buffer
, "#pragma omp target update");
2453 dump_omp_clauses (buffer
, OMP_TARGET_UPDATE_CLAUSES (node
), spc
, flags
);
2458 dump_omp_clauses (buffer
, OMP_FOR_CLAUSES (node
), spc
, flags
);
2460 if (!(flags
& TDF_SLIM
))
2464 if (OMP_FOR_PRE_BODY (node
))
2466 newline_and_indent (buffer
, spc
+ 2);
2467 pp_left_brace (buffer
);
2469 newline_and_indent (buffer
, spc
);
2470 dump_generic_node (buffer
, OMP_FOR_PRE_BODY (node
),
2473 if (OMP_FOR_INIT (node
))
2476 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
2479 newline_and_indent (buffer
, spc
);
2480 pp_string (buffer
, "for (");
2481 dump_generic_node (buffer
,
2482 TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
2484 pp_string (buffer
, "; ");
2485 dump_generic_node (buffer
,
2486 TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
2488 pp_string (buffer
, "; ");
2489 dump_generic_node (buffer
,
2490 TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
2492 pp_right_paren (buffer
);
2495 if (OMP_FOR_BODY (node
))
2497 newline_and_indent (buffer
, spc
+ 2);
2498 pp_left_brace (buffer
);
2499 newline_and_indent (buffer
, spc
+ 4);
2500 dump_generic_node (buffer
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
2502 newline_and_indent (buffer
, spc
+ 2);
2503 pp_right_brace (buffer
);
2505 if (OMP_FOR_INIT (node
))
2506 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
2507 if (OMP_FOR_PRE_BODY (node
))
2510 newline_and_indent (buffer
, spc
+ 2);
2511 pp_right_brace (buffer
);
2518 pp_string (buffer
, "#pragma omp sections");
2519 dump_omp_clauses (buffer
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
2523 pp_string (buffer
, "#pragma omp section");
2527 pp_string (buffer
, "#pragma omp master");
2531 pp_string (buffer
, "#pragma omp taskgroup");
2535 pp_string (buffer
, "#pragma omp ordered");
2539 pp_string (buffer
, "#pragma omp critical");
2540 if (OMP_CRITICAL_NAME (node
))
2543 pp_left_paren (buffer
);
2544 dump_generic_node (buffer
, OMP_CRITICAL_NAME (node
), spc
,
2546 pp_right_paren (buffer
);
2551 pp_string (buffer
, "#pragma omp atomic");
2552 if (OMP_ATOMIC_SEQ_CST (node
))
2553 pp_string (buffer
, " seq_cst");
2554 newline_and_indent (buffer
, spc
+ 2);
2555 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2559 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2562 case OMP_ATOMIC_READ
:
2563 pp_string (buffer
, "#pragma omp atomic read");
2564 if (OMP_ATOMIC_SEQ_CST (node
))
2565 pp_string (buffer
, " seq_cst");
2566 newline_and_indent (buffer
, spc
+ 2);
2567 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2571 case OMP_ATOMIC_CAPTURE_OLD
:
2572 case OMP_ATOMIC_CAPTURE_NEW
:
2573 pp_string (buffer
, "#pragma omp atomic capture");
2574 if (OMP_ATOMIC_SEQ_CST (node
))
2575 pp_string (buffer
, " seq_cst");
2576 newline_and_indent (buffer
, spc
+ 2);
2577 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2581 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2585 pp_string (buffer
, "#pragma omp single");
2586 dump_omp_clauses (buffer
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
2590 dump_omp_clause (buffer
, node
, spc
, flags
);
2594 case TRANSACTION_EXPR
:
2595 if (TRANSACTION_EXPR_OUTER (node
))
2596 pp_string (buffer
, "__transaction_atomic [[outer]]");
2597 else if (TRANSACTION_EXPR_RELAXED (node
))
2598 pp_string (buffer
, "__transaction_relaxed");
2600 pp_string (buffer
, "__transaction_atomic");
2601 if (!(flags
& TDF_SLIM
) && TRANSACTION_EXPR_BODY (node
))
2603 newline_and_indent (buffer
, spc
);
2604 pp_left_brace (buffer
);
2605 newline_and_indent (buffer
, spc
+ 2);
2606 dump_generic_node (buffer
, TRANSACTION_EXPR_BODY (node
),
2607 spc
+ 2, flags
, false);
2608 newline_and_indent (buffer
, spc
);
2609 pp_right_brace (buffer
);
2614 case REDUC_MAX_EXPR
:
2615 pp_string (buffer
, " REDUC_MAX_EXPR < ");
2616 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2617 pp_string (buffer
, " > ");
2620 case REDUC_MIN_EXPR
:
2621 pp_string (buffer
, " REDUC_MIN_EXPR < ");
2622 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2623 pp_string (buffer
, " > ");
2626 case REDUC_PLUS_EXPR
:
2627 pp_string (buffer
, " REDUC_PLUS_EXPR < ");
2628 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2629 pp_string (buffer
, " > ");
2632 case VEC_WIDEN_MULT_HI_EXPR
:
2633 case VEC_WIDEN_MULT_LO_EXPR
:
2634 case VEC_WIDEN_MULT_EVEN_EXPR
:
2635 case VEC_WIDEN_MULT_ODD_EXPR
:
2636 case VEC_WIDEN_LSHIFT_HI_EXPR
:
2637 case VEC_WIDEN_LSHIFT_LO_EXPR
:
2639 for (str
= get_tree_code_name (code
); *str
; str
++)
2640 pp_character (buffer
, TOUPPER (*str
));
2641 pp_string (buffer
, " < ");
2642 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2643 pp_string (buffer
, ", ");
2644 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2645 pp_string (buffer
, " > ");
2648 case VEC_UNPACK_HI_EXPR
:
2649 pp_string (buffer
, " VEC_UNPACK_HI_EXPR < ");
2650 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2651 pp_string (buffer
, " > ");
2654 case VEC_UNPACK_LO_EXPR
:
2655 pp_string (buffer
, " VEC_UNPACK_LO_EXPR < ");
2656 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2657 pp_string (buffer
, " > ");
2660 case VEC_UNPACK_FLOAT_HI_EXPR
:
2661 pp_string (buffer
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2662 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2663 pp_string (buffer
, " > ");
2666 case VEC_UNPACK_FLOAT_LO_EXPR
:
2667 pp_string (buffer
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2668 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2669 pp_string (buffer
, " > ");
2672 case VEC_PACK_TRUNC_EXPR
:
2673 pp_string (buffer
, " VEC_PACK_TRUNC_EXPR < ");
2674 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2675 pp_string (buffer
, ", ");
2676 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2677 pp_string (buffer
, " > ");
2680 case VEC_PACK_SAT_EXPR
:
2681 pp_string (buffer
, " VEC_PACK_SAT_EXPR < ");
2682 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2683 pp_string (buffer
, ", ");
2684 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2685 pp_string (buffer
, " > ");
2688 case VEC_PACK_FIX_TRUNC_EXPR
:
2689 pp_string (buffer
, " VEC_PACK_FIX_TRUNC_EXPR < ");
2690 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2691 pp_string (buffer
, ", ");
2692 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2693 pp_string (buffer
, " > ");
2697 dump_block_node (buffer
, node
, spc
, flags
);
2700 case CILK_SPAWN_STMT
:
2701 pp_string (buffer
, "_Cilk_spawn ");
2702 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2705 case CILK_SYNC_STMT
:
2706 pp_string (buffer
, "_Cilk_sync");
2713 if (is_stmt
&& is_expr
)
2714 pp_semicolon (buffer
);
2719 /* Print the declaration of a variable. */
2722 print_declaration (pretty_printer
*buffer
, tree t
, int spc
, int flags
)
2726 if (TREE_CODE(t
) == NAMELIST_DECL
)
2728 pp_string(buffer
, "namelist ");
2729 dump_decl_name (buffer
, t
, flags
);
2730 pp_semicolon (buffer
);
2734 if (TREE_CODE (t
) == TYPE_DECL
)
2735 pp_string (buffer
, "typedef ");
2737 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
2738 pp_string (buffer
, "register ");
2740 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
2741 pp_string (buffer
, "extern ");
2742 else if (TREE_STATIC (t
))
2743 pp_string (buffer
, "static ");
2745 /* Print the type and name. */
2746 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
2750 /* Print array's type. */
2751 tmp
= TREE_TYPE (t
);
2752 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
2753 tmp
= TREE_TYPE (tmp
);
2754 dump_generic_node (buffer
, TREE_TYPE (tmp
), spc
, flags
, false);
2756 /* Print variable's name. */
2758 dump_generic_node (buffer
, t
, spc
, flags
, false);
2760 /* Print the dimensions. */
2761 tmp
= TREE_TYPE (t
);
2762 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
2764 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
2765 tmp
= TREE_TYPE (tmp
);
2768 else if (TREE_CODE (t
) == FUNCTION_DECL
)
2770 dump_generic_node (buffer
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
2772 dump_decl_name (buffer
, t
, flags
);
2773 dump_function_declaration (buffer
, TREE_TYPE (t
), spc
, flags
);
2777 /* Print type declaration. */
2778 dump_generic_node (buffer
, TREE_TYPE (t
), spc
, flags
, false);
2780 /* Print variable's name. */
2782 dump_generic_node (buffer
, t
, spc
, flags
, false);
2785 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
2787 pp_string (buffer
, " __asm__ ");
2788 pp_left_paren (buffer
);
2789 dump_generic_node (buffer
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
2790 pp_right_paren (buffer
);
2793 /* The initial value of a function serves to determine whether the function
2794 is declared or defined. So the following does not apply to function
2796 if (TREE_CODE (t
) != FUNCTION_DECL
)
2798 /* Print the initial value. */
2799 if (DECL_INITIAL (t
))
2804 dump_generic_node (buffer
, DECL_INITIAL (t
), spc
, flags
, false);
2808 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
2810 pp_string (buffer
, " [value-expr: ");
2811 dump_generic_node (buffer
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
2812 pp_right_bracket (buffer
);
2815 pp_semicolon (buffer
);
2819 /* Prints a structure: name, fields, and methods.
2820 FIXME: Still incomplete. */
2823 print_struct_decl (pretty_printer
*buffer
, const_tree node
, int spc
, int flags
)
2825 /* Print the name of the structure. */
2826 if (TYPE_NAME (node
))
2829 if (TREE_CODE (node
) == RECORD_TYPE
)
2830 pp_string (buffer
, "struct ");
2831 else if ((TREE_CODE (node
) == UNION_TYPE
2832 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
2833 pp_string (buffer
, "union ");
2835 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, 0, false);
2838 /* Print the contents of the structure. */
2839 pp_newline (buffer
);
2841 pp_left_brace (buffer
);
2842 pp_newline (buffer
);
2844 /* Print the fields of the structure. */
2847 tmp
= TYPE_FIELDS (node
);
2850 /* Avoid to print recursively the structure. */
2851 /* FIXME : Not implemented correctly...,
2852 what about the case when we have a cycle in the contain graph? ...
2853 Maybe this could be solved by looking at the scope in which the
2854 structure was declared. */
2855 if (TREE_TYPE (tmp
) != node
2856 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
2857 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
2859 print_declaration (buffer
, tmp
, spc
+2, flags
);
2860 pp_newline (buffer
);
2862 tmp
= DECL_CHAIN (tmp
);
2866 pp_right_brace (buffer
);
2869 /* Return the priority of the operator CODE.
2871 From lowest to highest precedence with either left-to-right (L-R)
2872 or right-to-left (R-L) associativity]:
2875 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2887 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2888 15 [L-R] fn() [] -> .
2890 unary +, - and * have higher precedence than the corresponding binary
2894 op_code_prio (enum tree_code code
)
2911 case TRUTH_ORIF_EXPR
:
2914 case TRUTH_AND_EXPR
:
2915 case TRUTH_ANDIF_EXPR
:
2922 case TRUTH_XOR_EXPR
:
2939 case UNORDERED_EXPR
:
2950 case VEC_WIDEN_LSHIFT_HI_EXPR
:
2951 case VEC_WIDEN_LSHIFT_LO_EXPR
:
2952 case WIDEN_LSHIFT_EXPR
:
2955 case WIDEN_SUM_EXPR
:
2957 case POINTER_PLUS_EXPR
:
2961 case VEC_WIDEN_MULT_HI_EXPR
:
2962 case VEC_WIDEN_MULT_LO_EXPR
:
2963 case WIDEN_MULT_EXPR
:
2965 case WIDEN_MULT_PLUS_EXPR
:
2966 case WIDEN_MULT_MINUS_EXPR
:
2968 case MULT_HIGHPART_EXPR
:
2969 case TRUNC_DIV_EXPR
:
2971 case FLOOR_DIV_EXPR
:
2972 case ROUND_DIV_EXPR
:
2974 case EXACT_DIV_EXPR
:
2975 case TRUNC_MOD_EXPR
:
2977 case FLOOR_MOD_EXPR
:
2978 case ROUND_MOD_EXPR
:
2982 case TRUTH_NOT_EXPR
:
2984 case POSTINCREMENT_EXPR
:
2985 case POSTDECREMENT_EXPR
:
2986 case PREINCREMENT_EXPR
:
2987 case PREDECREMENT_EXPR
:
2993 case FIX_TRUNC_EXPR
:
2999 case ARRAY_RANGE_REF
:
3003 /* Special expressions. */
3009 case REDUC_MAX_EXPR
:
3010 case REDUC_MIN_EXPR
:
3011 case REDUC_PLUS_EXPR
:
3012 case VEC_LSHIFT_EXPR
:
3013 case VEC_RSHIFT_EXPR
:
3014 case VEC_UNPACK_HI_EXPR
:
3015 case VEC_UNPACK_LO_EXPR
:
3016 case VEC_UNPACK_FLOAT_HI_EXPR
:
3017 case VEC_UNPACK_FLOAT_LO_EXPR
:
3018 case VEC_PACK_TRUNC_EXPR
:
3019 case VEC_PACK_SAT_EXPR
:
3023 /* Return an arbitrarily high precedence to avoid surrounding single
3024 VAR_DECLs in ()s. */
3029 /* Return the priority of the operator OP. */
3032 op_prio (const_tree op
)
3034 enum tree_code code
;
3039 code
= TREE_CODE (op
);
3040 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
3041 return op_prio (TREE_OPERAND (op
, 0));
3043 return op_code_prio (code
);
3046 /* Return the symbol associated with operator CODE. */
3049 op_symbol_code (enum tree_code code
)
3057 case TRUTH_ORIF_EXPR
:
3060 case TRUTH_AND_EXPR
:
3061 case TRUTH_ANDIF_EXPR
:
3067 case TRUTH_XOR_EXPR
:
3077 case UNORDERED_EXPR
:
3123 case VEC_LSHIFT_EXPR
:
3126 case VEC_RSHIFT_EXPR
:
3129 case WIDEN_LSHIFT_EXPR
:
3132 case POINTER_PLUS_EXPR
:
3138 case REDUC_PLUS_EXPR
:
3141 case WIDEN_SUM_EXPR
:
3144 case WIDEN_MULT_EXPR
:
3147 case MULT_HIGHPART_EXPR
:
3157 case TRUTH_NOT_EXPR
:
3164 case TRUNC_DIV_EXPR
:
3171 case FLOOR_DIV_EXPR
:
3174 case ROUND_DIV_EXPR
:
3177 case EXACT_DIV_EXPR
:
3180 case TRUNC_MOD_EXPR
:
3186 case FLOOR_MOD_EXPR
:
3189 case ROUND_MOD_EXPR
:
3192 case PREDECREMENT_EXPR
:
3195 case PREINCREMENT_EXPR
:
3198 case POSTDECREMENT_EXPR
:
3201 case POSTINCREMENT_EXPR
:
3211 return "<<< ??? >>>";
3215 /* Return the symbol associated with operator OP. */
3218 op_symbol (const_tree op
)
3220 return op_symbol_code (TREE_CODE (op
));
3223 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3224 the gimple_call_fn of a GIMPLE_CALL. */
3227 print_call_name (pretty_printer
*buffer
, tree node
, int flags
)
3231 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3232 op0
= TREE_OPERAND (op0
, 0);
3235 switch (TREE_CODE (op0
))
3240 dump_function_name (buffer
, op0
, flags
);
3246 op0
= TREE_OPERAND (op0
, 0);
3250 pp_left_paren (buffer
);
3251 dump_generic_node (buffer
, TREE_OPERAND (op0
, 0), 0, flags
, false);
3252 pp_string (buffer
, ") ? ");
3253 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1), 0, flags
, false);
3254 pp_string (buffer
, " : ");
3255 dump_generic_node (buffer
, TREE_OPERAND (op0
, 2), 0, flags
, false);
3259 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
3260 dump_function_name (buffer
, TREE_OPERAND (op0
, 0), flags
);
3262 dump_generic_node (buffer
, op0
, 0, flags
, false);
3266 if (integer_zerop (TREE_OPERAND (op0
, 1)))
3268 op0
= TREE_OPERAND (op0
, 0);
3275 dump_generic_node (buffer
, op0
, 0, flags
, false);
3283 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3286 pretty_print_string (pretty_printer
*buffer
, const char *str
)
3296 pp_string (buffer
, "\\b");
3300 pp_string (buffer
, "\\f");
3304 pp_string (buffer
, "\\n");
3308 pp_string (buffer
, "\\r");
3312 pp_string (buffer
, "\\t");
3316 pp_string (buffer
, "\\v");
3320 pp_string (buffer
, "\\\\");
3324 pp_string (buffer
, "\\\"");
3328 pp_string (buffer
, "\\'");
3331 /* No need to handle \0; the loop terminates on \0. */
3334 pp_string (buffer
, "\\1");
3338 pp_string (buffer
, "\\2");
3342 pp_string (buffer
, "\\3");
3346 pp_string (buffer
, "\\4");
3350 pp_string (buffer
, "\\5");
3354 pp_string (buffer
, "\\6");
3358 pp_string (buffer
, "\\7");
3362 pp_character (buffer
, str
[0]);
3370 maybe_init_pretty_print (FILE *file
)
3374 new (&buffer
) pretty_printer ();
3375 pp_needs_newline (&buffer
) = true;
3376 pp_translate_identifiers (&buffer
) = false;
3380 buffer
.buffer
->stream
= file
;
3384 newline_and_indent (pretty_printer
*buffer
, int spc
)
3386 pp_newline (buffer
);
3390 /* Handle a %K format for TEXT. Separate from default_tree_printer so
3391 it can also be used in front ends.
3392 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3396 percent_K_format (text_info
*text
)
3398 tree t
= va_arg (*text
->args_ptr
, tree
), block
;
3399 gcc_assert (text
->locus
!= NULL
);
3400 *text
->locus
= EXPR_LOCATION (t
);
3401 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
3402 block
= TREE_BLOCK (t
);
3403 *pp_ti_abstract_origin (text
) = NULL
;
3407 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3408 representing the outermost block of an inlined function.
3409 So walk the BLOCK tree until we hit such a scope. */
3411 && TREE_CODE (block
) == BLOCK
)
3413 if (inlined_function_outer_scope_p (block
))
3415 *pp_ti_abstract_origin (text
) = block
;
3418 block
= BLOCK_SUPERCONTEXT (block
);
3424 && TREE_CODE (block
) == BLOCK
3425 && BLOCK_ABSTRACT_ORIGIN (block
))
3427 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3429 while (TREE_CODE (ao
) == BLOCK
3430 && BLOCK_ABSTRACT_ORIGIN (ao
)
3431 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3432 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3434 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3436 *pp_ti_abstract_origin (text
) = block
;
3439 block
= BLOCK_SUPERCONTEXT (block
);
3443 /* Print the identifier ID to PRETTY-PRINTER. */
3446 pp_tree_identifier (pretty_printer
*pp
, tree id
)
3448 if (pp_translate_identifiers (pp
))
3450 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
3451 pp_append_text (pp
, text
, text
+ strlen (text
));
3454 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
3455 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));
3458 /* A helper function that is used to dump function information before the
3462 dump_function_header (FILE *dump_file
, tree fdecl
, int flags
)
3464 const char *dname
, *aname
;
3465 struct cgraph_node
*node
= cgraph_get_node (fdecl
);
3466 struct function
*fun
= DECL_STRUCT_FUNCTION (fdecl
);
3468 dname
= lang_hooks
.decl_printable_name (fdecl
, 2);
3470 if (DECL_ASSEMBLER_NAME_SET_P (fdecl
))
3471 aname
= (IDENTIFIER_POINTER
3472 (DECL_ASSEMBLER_NAME (fdecl
)));
3474 aname
= "<unset-asm-name>";
3476 fprintf (dump_file
, "\n;; Function %s (%s, funcdef_no=%d",
3477 dname
, aname
, fun
->funcdef_no
);
3478 if (!(flags
& TDF_NOUID
))
3479 fprintf (dump_file
, ", decl_uid=%d", DECL_UID (fdecl
));
3482 fprintf (dump_file
, ", symbol_order=%d)%s\n\n", node
->order
,
3483 node
->frequency
== NODE_FREQUENCY_HOT
3485 : node
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
3486 ? " (unlikely executed)"
3487 : node
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
3488 ? " (executed once)"
3492 fprintf (dump_file
, ")\n\n");
3495 /* Dump double_int D to pretty_printer PP. UNS is true
3496 if D is unsigned and false otherwise. */
3498 pp_double_int (pretty_printer
*pp
, double_int d
, bool uns
)
3501 pp_wide_integer (pp
, d
.low
);
3502 else if (d
.fits_uhwi ())
3503 pp_unsigned_wide_integer (pp
, d
.low
);
3506 unsigned HOST_WIDE_INT low
= d
.low
;
3507 HOST_WIDE_INT high
= d
.high
;
3508 if (!uns
&& d
.is_negative ())
3511 high
= ~high
+ !low
;
3514 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
3516 sprintf (pp_buffer (pp
)->digit_buffer
,
3517 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
3518 (unsigned HOST_WIDE_INT
) high
, low
);
3519 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);