1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
28 #include "diagnostic.h"
29 #include "tree-pretty-print.h"
31 #include "tree-flow.h"
32 #include "langhooks.h"
33 #include "tree-iterator.h"
34 #include "tree-chrec.h"
35 #include "tree-pass.h"
36 #include "value-prof.h"
39 /* Local functions, macros and variables. */
40 static const char *op_symbol (const_tree
);
41 static void pretty_print_string (pretty_printer
*, const char*);
42 static void newline_and_indent (pretty_printer
*, int);
43 static void maybe_init_pretty_print (FILE *);
44 static void print_struct_decl (pretty_printer
*, const_tree
, int, int);
45 static void do_niy (pretty_printer
*, const_tree
);
47 #define INDENT(SPACE) do { \
48 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
50 #define NIY do_niy(buffer,node)
52 static pretty_printer buffer
;
53 static int initialized
= 0;
55 /* Try to print something for an unknown tree code. */
58 do_niy (pretty_printer
*buffer
, const_tree node
)
62 pp_string (buffer
, "<<< Unknown tree: ");
63 pp_string (buffer
, tree_code_name
[(int) TREE_CODE (node
)]);
67 len
= TREE_OPERAND_LENGTH (node
);
68 for (i
= 0; i
< len
; ++i
)
70 newline_and_indent (buffer
, 2);
71 dump_generic_node (buffer
, TREE_OPERAND (node
, i
), 2, 0, false);
75 pp_string (buffer
, " >>>\n");
78 /* Debugging function to print out a generic expression. */
81 debug_generic_expr (tree t
)
83 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
84 fprintf (stderr
, "\n");
87 /* Debugging function to print out a generic statement. */
90 debug_generic_stmt (tree t
)
92 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
93 fprintf (stderr
, "\n");
96 /* Debugging function to print out a chain of trees . */
99 debug_tree_chain (tree t
)
101 struct pointer_set_t
*seen
= pointer_set_create ();
105 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
106 fprintf (stderr
, " ");
108 if (pointer_set_insert (seen
, t
))
110 fprintf (stderr
, "... [cycled back to ");
111 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
112 fprintf (stderr
, "]");
116 fprintf (stderr
, "\n");
118 pointer_set_destroy (seen
);
121 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
123 print_generic_decl (FILE *file
, tree decl
, int flags
)
125 maybe_init_pretty_print (file
);
126 print_declaration (&buffer
, decl
, 2, flags
);
127 pp_write_text_to_stream (&buffer
);
130 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
131 to show in the dump. See TDF_* in tree-pass.h. */
134 print_generic_stmt (FILE *file
, tree t
, int flags
)
136 maybe_init_pretty_print (file
);
137 dump_generic_node (&buffer
, t
, 0, flags
, true);
141 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
142 to show in the dump. See TDF_* in tree-pass.h. The output is indented by
146 print_generic_stmt_indented (FILE *file
, tree t
, int flags
, int indent
)
150 maybe_init_pretty_print (file
);
152 for (i
= 0; i
< indent
; i
++)
154 dump_generic_node (&buffer
, t
, indent
, flags
, true);
158 /* Print a single expression T on file FILE. FLAGS specifies details to show
159 in the dump. See TDF_* in tree-pass.h. */
162 print_generic_expr (FILE *file
, tree t
, int flags
)
164 maybe_init_pretty_print (file
);
165 dump_generic_node (&buffer
, t
, 0, flags
, false);
168 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
172 dump_decl_name (pretty_printer
*buffer
, tree node
, int flags
)
174 if (DECL_NAME (node
))
176 if ((flags
& TDF_ASMNAME
) && DECL_ASSEMBLER_NAME_SET_P (node
))
177 pp_tree_identifier (buffer
, DECL_ASSEMBLER_NAME (node
));
179 pp_tree_identifier (buffer
, DECL_NAME (node
));
181 if ((flags
& TDF_UID
) || DECL_NAME (node
) == NULL_TREE
)
183 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
184 pp_printf (buffer
, "L.%d", (int) LABEL_DECL_UID (node
));
185 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
187 if (flags
& TDF_NOUID
)
188 pp_string (buffer
, "D#xxxx");
190 pp_printf (buffer
, "D#%i", DEBUG_TEMP_UID (node
));
194 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
195 if (flags
& TDF_NOUID
)
196 pp_printf (buffer
, "%c.xxxx", c
);
198 pp_printf (buffer
, "%c.%u", c
, DECL_UID (node
));
201 if ((flags
& TDF_ALIAS
) && DECL_PT_UID (node
) != DECL_UID (node
))
203 if (flags
& TDF_NOUID
)
204 pp_printf (buffer
, "ptD.xxxx");
206 pp_printf (buffer
, "ptD.%u", DECL_PT_UID (node
));
210 /* Like the above, but used for pretty printing function calls. */
213 dump_function_name (pretty_printer
*buffer
, tree node
, int flags
)
215 if (TREE_CODE (node
) == NOP_EXPR
)
216 node
= TREE_OPERAND (node
, 0);
217 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
218 pp_string (buffer
, lang_hooks
.decl_printable_name (node
, 1));
220 dump_decl_name (buffer
, node
, flags
);
223 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
224 FLAGS are as in dump_generic_node. */
227 dump_function_declaration (pretty_printer
*buffer
, tree node
,
230 bool wrote_arg
= false;
234 pp_character (buffer
, '(');
236 /* Print the argument types. The last element in the list is a VOID_TYPE.
237 The following avoids printing the last element. */
238 arg
= TYPE_ARG_TYPES (node
);
239 while (arg
&& TREE_CHAIN (arg
) && arg
!= error_mark_node
)
242 dump_generic_node (buffer
, TREE_VALUE (arg
), spc
, flags
, false);
243 arg
= TREE_CHAIN (arg
);
244 if (TREE_CHAIN (arg
) && TREE_CODE (TREE_CHAIN (arg
)) == TREE_LIST
)
246 pp_character (buffer
, ',');
252 pp_string (buffer
, "void");
254 pp_character (buffer
, ')');
257 /* Dump the domain associated with an array. */
260 dump_array_domain (pretty_printer
*buffer
, tree domain
, int spc
, int flags
)
262 pp_character (buffer
, '[');
265 tree min
= TYPE_MIN_VALUE (domain
);
266 tree max
= TYPE_MAX_VALUE (domain
);
269 && integer_zerop (min
)
270 && host_integerp (max
, 0))
271 pp_wide_integer (buffer
, TREE_INT_CST_LOW (max
) + 1);
275 dump_generic_node (buffer
, min
, spc
, flags
, false);
276 pp_character (buffer
, ':');
278 dump_generic_node (buffer
, max
, spc
, flags
, false);
282 pp_string (buffer
, "<unknown>");
283 pp_character (buffer
, ']');
287 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
288 dump_generic_node. */
291 dump_omp_clause (pretty_printer
*buffer
, tree clause
, int spc
, int flags
)
295 switch (OMP_CLAUSE_CODE (clause
))
297 case OMP_CLAUSE_PRIVATE
:
300 case OMP_CLAUSE_SHARED
:
303 case OMP_CLAUSE_FIRSTPRIVATE
:
304 name
= "firstprivate";
306 case OMP_CLAUSE_LASTPRIVATE
:
307 name
= "lastprivate";
309 case OMP_CLAUSE_COPYIN
:
312 case OMP_CLAUSE_COPYPRIVATE
:
313 name
= "copyprivate";
316 pp_string (buffer
, name
);
317 pp_character (buffer
, '(');
318 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
320 pp_character (buffer
, ')');
323 case OMP_CLAUSE_REDUCTION
:
324 pp_string (buffer
, "reduction(");
325 pp_string (buffer
, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
326 pp_character (buffer
, ':');
327 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
329 pp_character (buffer
, ')');
333 pp_string (buffer
, "if(");
334 dump_generic_node (buffer
, OMP_CLAUSE_IF_EXPR (clause
),
336 pp_character (buffer
, ')');
339 case OMP_CLAUSE_NUM_THREADS
:
340 pp_string (buffer
, "num_threads(");
341 dump_generic_node (buffer
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
343 pp_character (buffer
, ')');
346 case OMP_CLAUSE_NOWAIT
:
347 pp_string (buffer
, "nowait");
349 case OMP_CLAUSE_ORDERED
:
350 pp_string (buffer
, "ordered");
353 case OMP_CLAUSE_DEFAULT
:
354 pp_string (buffer
, "default(");
355 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
357 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
359 case OMP_CLAUSE_DEFAULT_SHARED
:
360 pp_string (buffer
, "shared");
362 case OMP_CLAUSE_DEFAULT_NONE
:
363 pp_string (buffer
, "none");
365 case OMP_CLAUSE_DEFAULT_PRIVATE
:
366 pp_string (buffer
, "private");
368 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
369 pp_string (buffer
, "firstprivate");
374 pp_character (buffer
, ')');
377 case OMP_CLAUSE_SCHEDULE
:
378 pp_string (buffer
, "schedule(");
379 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
))
381 case OMP_CLAUSE_SCHEDULE_STATIC
:
382 pp_string (buffer
, "static");
384 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
385 pp_string (buffer
, "dynamic");
387 case OMP_CLAUSE_SCHEDULE_GUIDED
:
388 pp_string (buffer
, "guided");
390 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
391 pp_string (buffer
, "runtime");
393 case OMP_CLAUSE_SCHEDULE_AUTO
:
394 pp_string (buffer
, "auto");
399 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
401 pp_character (buffer
, ',');
402 dump_generic_node (buffer
,
403 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
406 pp_character (buffer
, ')');
409 case OMP_CLAUSE_UNTIED
:
410 pp_string (buffer
, "untied");
413 case OMP_CLAUSE_COLLAPSE
:
414 pp_string (buffer
, "collapse(");
415 dump_generic_node (buffer
,
416 OMP_CLAUSE_COLLAPSE_EXPR (clause
),
418 pp_character (buffer
, ')');
422 /* Should never happen. */
423 dump_generic_node (buffer
, clause
, spc
, flags
, false);
429 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
430 dump_generic_node. */
433 dump_omp_clauses (pretty_printer
*buffer
, tree clause
, int spc
, int flags
)
441 dump_omp_clause (buffer
, clause
, spc
, flags
);
442 clause
= OMP_CLAUSE_CHAIN (clause
);
450 /* Dump location LOC to BUFFER. */
453 dump_location (pretty_printer
*buffer
, location_t loc
)
455 expanded_location xloc
= expand_location (loc
);
457 pp_character (buffer
, '[');
460 pp_string (buffer
, xloc
.file
);
461 pp_string (buffer
, " : ");
463 pp_decimal_int (buffer
, xloc
.line
);
464 pp_string (buffer
, "] ");
468 /* Dump lexical block BLOCK. BUFFER, SPC and FLAGS are as in
469 dump_generic_node. */
472 dump_block_node (pretty_printer
*buffer
, tree block
, int spc
, int flags
)
476 pp_printf (buffer
, "BLOCK #%d ", BLOCK_NUMBER (block
));
478 if (flags
& TDF_ADDRESS
)
479 pp_printf (buffer
, "[%p] ", (void *) block
);
481 if (BLOCK_ABSTRACT (block
))
482 pp_string (buffer
, "[abstract] ");
484 if (TREE_ASM_WRITTEN (block
))
485 pp_string (buffer
, "[written] ");
487 if (flags
& TDF_SLIM
)
490 if (BLOCK_SOURCE_LOCATION (block
))
491 dump_location (buffer
, BLOCK_SOURCE_LOCATION (block
));
493 newline_and_indent (buffer
, spc
+ 2);
495 if (BLOCK_SUPERCONTEXT (block
))
497 pp_string (buffer
, "SUPERCONTEXT: ");
498 dump_generic_node (buffer
, BLOCK_SUPERCONTEXT (block
), 0,
499 flags
| TDF_SLIM
, false);
500 newline_and_indent (buffer
, spc
+ 2);
503 if (BLOCK_SUBBLOCKS (block
))
505 pp_string (buffer
, "SUBBLOCKS: ");
506 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
508 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
509 pp_string (buffer
, " ");
511 newline_and_indent (buffer
, spc
+ 2);
514 if (BLOCK_CHAIN (block
))
516 pp_string (buffer
, "SIBLINGS: ");
517 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
519 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
520 pp_string (buffer
, " ");
522 newline_and_indent (buffer
, spc
+ 2);
525 if (BLOCK_VARS (block
))
527 pp_string (buffer
, "VARS: ");
528 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
530 dump_generic_node (buffer
, t
, 0, flags
, false);
531 pp_string (buffer
, " ");
533 newline_and_indent (buffer
, spc
+ 2);
536 if (VEC_length (tree
, BLOCK_NONLOCALIZED_VARS (block
)) > 0)
539 VEC(tree
,gc
) *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
541 pp_string (buffer
, "NONLOCALIZED_VARS: ");
542 for (i
= 0; VEC_iterate (tree
, nlv
, i
, t
); i
++)
544 dump_generic_node (buffer
, t
, 0, flags
, false);
545 pp_string (buffer
, " ");
547 newline_and_indent (buffer
, spc
+ 2);
550 if (BLOCK_ABSTRACT_ORIGIN (block
))
552 pp_string (buffer
, "ABSTRACT_ORIGIN: ");
553 dump_generic_node (buffer
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
554 flags
| TDF_SLIM
, false);
555 newline_and_indent (buffer
, spc
+ 2);
558 if (BLOCK_FRAGMENT_ORIGIN (block
))
560 pp_string (buffer
, "FRAGMENT_ORIGIN: ");
561 dump_generic_node (buffer
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
562 flags
| TDF_SLIM
, false);
563 newline_and_indent (buffer
, spc
+ 2);
566 if (BLOCK_FRAGMENT_CHAIN (block
))
568 pp_string (buffer
, "FRAGMENT_CHAIN: ");
569 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
571 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
572 pp_string (buffer
, " ");
574 newline_and_indent (buffer
, spc
+ 2);
579 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
580 indent. FLAGS specifies details to show in the dump (see TDF_* in
581 tree-pass.h). If IS_STMT is true, the object printed is considered
582 to be a statement and it is terminated by ';' if appropriate. */
585 dump_generic_node (pretty_printer
*buffer
, tree node
, int spc
, int flags
,
593 if (node
== NULL_TREE
)
596 is_expr
= EXPR_P (node
);
598 if (is_stmt
&& (flags
& TDF_STMTADDR
))
599 pp_printf (buffer
, "<&%p> ", (void *)node
);
601 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
602 dump_location (buffer
, EXPR_LOCATION (node
));
604 switch (TREE_CODE (node
))
607 pp_string (buffer
, "<<< error >>>");
610 case IDENTIFIER_NODE
:
611 pp_tree_identifier (buffer
, node
);
615 while (node
&& node
!= error_mark_node
)
617 if (TREE_PURPOSE (node
))
619 dump_generic_node (buffer
, TREE_PURPOSE (node
), spc
, flags
, false);
622 dump_generic_node (buffer
, TREE_VALUE (node
), spc
, flags
, false);
623 node
= TREE_CHAIN (node
);
624 if (node
&& TREE_CODE (node
) == TREE_LIST
)
626 pp_character (buffer
, ',');
633 dump_generic_node (buffer
, BINFO_TYPE (node
), spc
, flags
, false);
639 if (TREE_VEC_LENGTH (node
) > 0)
641 size_t len
= TREE_VEC_LENGTH (node
);
642 for (i
= 0; i
< len
- 1; i
++)
644 dump_generic_node (buffer
, TREE_VEC_ELT (node
, i
), spc
, flags
,
646 pp_character (buffer
, ',');
649 dump_generic_node (buffer
, TREE_VEC_ELT (node
, len
- 1), spc
,
658 case FIXED_POINT_TYPE
:
664 unsigned int quals
= TYPE_QUALS (node
);
665 enum tree_code_class tclass
;
667 if (quals
& TYPE_QUAL_CONST
)
668 pp_string (buffer
, "const ");
669 else if (quals
& TYPE_QUAL_VOLATILE
)
670 pp_string (buffer
, "volatile ");
671 else if (quals
& TYPE_QUAL_RESTRICT
)
672 pp_string (buffer
, "restrict ");
674 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
676 pp_string (buffer
, "<address-space-");
677 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
678 pp_string (buffer
, "> ");
681 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
683 if (tclass
== tcc_declaration
)
685 if (DECL_NAME (node
))
686 dump_decl_name (buffer
, node
, flags
);
688 pp_string (buffer
, "<unnamed type decl>");
690 else if (tclass
== tcc_type
)
692 if (TYPE_NAME (node
))
694 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
695 pp_tree_identifier (buffer
, TYPE_NAME (node
));
696 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
697 && DECL_NAME (TYPE_NAME (node
)))
698 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
700 pp_string (buffer
, "<unnamed type>");
702 else if (TREE_CODE (node
) == VECTOR_TYPE
)
704 pp_string (buffer
, "vector");
705 pp_character (buffer
, '(');
706 pp_wide_integer (buffer
, TYPE_VECTOR_SUBPARTS (node
));
707 pp_string (buffer
, ") ");
708 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
710 else if (TREE_CODE (node
) == INTEGER_TYPE
)
712 pp_string (buffer
, (TYPE_UNSIGNED (node
)
713 ? "<unnamed-unsigned:"
714 : "<unnamed-signed:"));
715 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
716 pp_string (buffer
, ">");
718 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
720 pp_string (buffer
, "__complex__ ");
721 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
723 else if (TREE_CODE (node
) == REAL_TYPE
)
725 pp_string (buffer
, "<float:");
726 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
727 pp_string (buffer
, ">");
729 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
731 pp_string (buffer
, "<fixed-point-");
732 pp_string (buffer
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
733 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
734 pp_string (buffer
, ">");
737 pp_string (buffer
, "<unnamed type>");
744 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
746 if (TREE_TYPE (node
) == NULL
)
748 pp_string (buffer
, str
);
749 pp_string (buffer
, "<null type>");
751 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
753 tree fnode
= TREE_TYPE (node
);
755 dump_generic_node (buffer
, TREE_TYPE (fnode
), spc
, flags
, false);
757 pp_character (buffer
, '(');
758 pp_string (buffer
, str
);
759 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
760 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
762 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
764 pp_character (buffer
, ')');
765 dump_function_declaration (buffer
, fnode
, spc
, flags
);
769 unsigned int quals
= TYPE_QUALS (node
);
771 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
773 pp_string (buffer
, str
);
775 if (quals
& TYPE_QUAL_CONST
)
776 pp_string (buffer
, " const");
777 if (quals
& TYPE_QUAL_VOLATILE
)
778 pp_string (buffer
, " volatile");
779 if (quals
& TYPE_QUAL_RESTRICT
)
780 pp_string (buffer
, " restrict");
782 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
784 pp_string (buffer
, " <address-space-");
785 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
786 pp_string (buffer
, ">");
789 if (TYPE_REF_CAN_ALIAS_ALL (node
))
790 pp_string (buffer
, " {ref-all}");
800 const char *sep
= "";
803 pp_string (buffer
, "MEM[");
805 tmp
= TMR_SYMBOL (node
);
808 pp_string (buffer
, sep
);
810 pp_string (buffer
, "symbol: ");
811 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
813 tmp
= TMR_BASE (node
);
816 pp_string (buffer
, sep
);
818 pp_string (buffer
, "base: ");
819 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
821 tmp
= TMR_INDEX (node
);
824 pp_string (buffer
, sep
);
826 pp_string (buffer
, "index: ");
827 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
829 tmp
= TMR_STEP (node
);
832 pp_string (buffer
, sep
);
834 pp_string (buffer
, "step: ");
835 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
837 tmp
= TMR_OFFSET (node
);
840 pp_string (buffer
, sep
);
842 pp_string (buffer
, "offset: ");
843 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
845 pp_string (buffer
, "]");
846 if (flags
& TDF_DETAILS
)
848 pp_string (buffer
, "{");
849 dump_generic_node (buffer
, TMR_ORIGINAL (node
), spc
, flags
,
851 pp_string (buffer
, "}");
860 /* Print the innermost component type. */
861 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
862 tmp
= TREE_TYPE (tmp
))
864 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
866 /* Print the dimensions. */
867 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
868 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
874 case QUAL_UNION_TYPE
:
876 unsigned int quals
= TYPE_QUALS (node
);
878 if (quals
& TYPE_QUAL_CONST
)
879 pp_string (buffer
, "const ");
880 if (quals
& TYPE_QUAL_VOLATILE
)
881 pp_string (buffer
, "volatile ");
883 /* Print the name of the structure. */
884 if (TREE_CODE (node
) == RECORD_TYPE
)
885 pp_string (buffer
, "struct ");
886 else if (TREE_CODE (node
) == UNION_TYPE
)
887 pp_string (buffer
, "union ");
889 if (TYPE_NAME (node
))
890 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, flags
, false);
891 else if (!(flags
& TDF_SLIM
))
892 /* FIXME: If we eliminate the 'else' above and attempt
893 to show the fields for named types, we may get stuck
894 following a cycle of pointers to structs. The alleged
895 self-reference check in print_struct_decl will not detect
896 cycles involving more than one pointer or struct type. */
897 print_struct_decl (buffer
, node
, spc
, flags
);
906 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
908 /* In the case of a pointer, one may want to divide by the
909 size of the pointed-to type. Unfortunately, this not
910 straightforward. The C front-end maps expressions
915 in such a way that the two INTEGER_CST nodes for "5" have
916 different values but identical types. In the latter
917 case, the 5 is multiplied by sizeof (int) in c-common.c
918 (pointer_int_sum) to convert it to a byte address, and
919 yet the type of the node is left unchanged. Argh. What
920 is consistent though is that the number value corresponds
921 to bytes (UNITS) offset.
923 NB: Neither of the following divisors can be trivially
924 used to recover the original literal:
926 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
927 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
928 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
929 pp_string (buffer
, "B"); /* pseudo-unit */
931 else if (! host_integerp (node
, 0))
934 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (val
);
935 HOST_WIDE_INT high
= TREE_INT_CST_HIGH (val
);
937 if (tree_int_cst_sgn (val
) < 0)
939 pp_character (buffer
, '-');
943 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
945 sprintf (pp_buffer (buffer
)->digit_buffer
,
946 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
947 (unsigned HOST_WIDE_INT
) high
, low
);
948 pp_string (buffer
, pp_buffer (buffer
)->digit_buffer
);
951 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
955 /* Code copied from print_node. */
958 if (TREE_OVERFLOW (node
))
959 pp_string (buffer
, " overflow");
961 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
962 d
= TREE_REAL_CST (node
);
963 if (REAL_VALUE_ISINF (d
))
964 pp_string (buffer
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
965 else if (REAL_VALUE_ISNAN (d
))
966 pp_string (buffer
, " Nan");
970 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
971 pp_string (buffer
, string
);
976 unsigned char *p
= (unsigned char *) &TREE_REAL_CST (node
);
977 pp_string (buffer
, "0x");
978 for (i
= 0; i
< sizeof TREE_REAL_CST (node
); i
++)
979 output_formatted_integer (buffer
, "%02x", *p
++);
988 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
989 pp_string (buffer
, string
);
994 pp_string (buffer
, "__complex__ (");
995 dump_generic_node (buffer
, TREE_REALPART (node
), spc
, flags
, false);
996 pp_string (buffer
, ", ");
997 dump_generic_node (buffer
, TREE_IMAGPART (node
), spc
, flags
, false);
998 pp_string (buffer
, ")");
1002 pp_string (buffer
, "\"");
1003 pretty_print_string (buffer
, TREE_STRING_POINTER (node
));
1004 pp_string (buffer
, "\"");
1010 pp_string (buffer
, "{ ");
1011 for (elt
= TREE_VECTOR_CST_ELTS (node
); elt
; elt
= TREE_CHAIN (elt
))
1013 dump_generic_node (buffer
, TREE_VALUE (elt
), spc
, flags
, false);
1014 if (TREE_CHAIN (elt
))
1015 pp_string (buffer
, ", ");
1017 pp_string (buffer
, " }");
1023 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1025 if (TREE_CODE (node
) == METHOD_TYPE
)
1027 if (TYPE_METHOD_BASETYPE (node
))
1028 dump_decl_name (buffer
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1031 pp_string (buffer
, "<null method basetype>");
1032 pp_string (buffer
, "::");
1034 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1035 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
1037 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
1038 dump_function_declaration (buffer
, node
, spc
, flags
);
1043 dump_decl_name (buffer
, node
, flags
);
1047 if (DECL_NAME (node
))
1048 dump_decl_name (buffer
, node
, flags
);
1049 else if (LABEL_DECL_UID (node
) != -1)
1050 pp_printf (buffer
, "<L%d>", (int) LABEL_DECL_UID (node
));
1053 if (flags
& TDF_NOUID
)
1054 pp_string (buffer
, "<D.xxxx>");
1056 pp_printf (buffer
, "<D.%u>", DECL_UID (node
));
1061 if (DECL_IS_BUILTIN (node
))
1063 /* Don't print the declaration of built-in types. */
1066 if (DECL_NAME (node
))
1067 dump_decl_name (buffer
, node
, flags
);
1070 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1071 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1072 && TYPE_METHODS (TREE_TYPE (node
)))
1074 /* The type is a c++ class: all structures have at least
1076 pp_string (buffer
, "class ");
1077 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1082 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1083 ? "union" : "struct "));
1084 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1092 case DEBUG_EXPR_DECL
:
1093 case NAMESPACE_DECL
:
1094 dump_decl_name (buffer
, node
, flags
);
1098 pp_string (buffer
, "<retval>");
1102 op0
= TREE_OPERAND (node
, 0);
1104 if (op0
&& TREE_CODE (op0
) == INDIRECT_REF
)
1106 op0
= TREE_OPERAND (op0
, 0);
1109 if (op_prio (op0
) < op_prio (node
))
1110 pp_character (buffer
, '(');
1111 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1112 if (op_prio (op0
) < op_prio (node
))
1113 pp_character (buffer
, ')');
1114 pp_string (buffer
, str
);
1115 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1116 op0
= component_ref_field_offset (node
);
1117 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1119 pp_string (buffer
, "{off: ");
1120 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1121 pp_character (buffer
, '}');
1126 pp_string (buffer
, "BIT_FIELD_REF <");
1127 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1128 pp_string (buffer
, ", ");
1129 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1130 pp_string (buffer
, ", ");
1131 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1132 pp_string (buffer
, ">");
1136 case ARRAY_RANGE_REF
:
1137 op0
= TREE_OPERAND (node
, 0);
1138 if (op_prio (op0
) < op_prio (node
))
1139 pp_character (buffer
, '(');
1140 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1141 if (op_prio (op0
) < op_prio (node
))
1142 pp_character (buffer
, ')');
1143 pp_character (buffer
, '[');
1144 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1145 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1146 pp_string (buffer
, " ...");
1147 pp_character (buffer
, ']');
1149 op0
= array_ref_low_bound (node
);
1150 op1
= array_ref_element_size (node
);
1152 if (!integer_zerop (op0
)
1153 || TREE_OPERAND (node
, 2)
1154 || TREE_OPERAND (node
, 3))
1156 pp_string (buffer
, "{lb: ");
1157 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1158 pp_string (buffer
, " sz: ");
1159 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1160 pp_character (buffer
, '}');
1166 unsigned HOST_WIDE_INT ix
;
1168 bool is_struct_init
= FALSE
;
1169 pp_character (buffer
, '{');
1170 if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1171 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1172 is_struct_init
= TRUE
;
1173 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1175 if (field
&& is_struct_init
)
1177 pp_character (buffer
, '.');
1178 dump_generic_node (buffer
, field
, spc
, flags
, false);
1179 pp_string (buffer
, "=");
1181 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1182 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1183 val
= TREE_OPERAND (val
, 0);
1184 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1185 dump_decl_name (buffer
, val
, flags
);
1187 dump_generic_node (buffer
, val
, spc
, flags
, false);
1188 if (ix
!= VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (node
)) - 1)
1190 pp_character (buffer
, ',');
1194 pp_character (buffer
, '}');
1201 if (flags
& TDF_SLIM
)
1203 pp_string (buffer
, "<COMPOUND_EXPR>");
1207 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1208 spc
, flags
, !(flags
& TDF_SLIM
));
1209 if (flags
& TDF_SLIM
)
1210 newline_and_indent (buffer
, spc
);
1213 pp_character (buffer
, ',');
1217 for (tp
= &TREE_OPERAND (node
, 1);
1218 TREE_CODE (*tp
) == COMPOUND_EXPR
;
1219 tp
= &TREE_OPERAND (*tp
, 1))
1221 dump_generic_node (buffer
, TREE_OPERAND (*tp
, 0),
1222 spc
, flags
, !(flags
& TDF_SLIM
));
1223 if (flags
& TDF_SLIM
)
1224 newline_and_indent (buffer
, spc
);
1227 pp_character (buffer
, ',');
1232 dump_generic_node (buffer
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
1236 case STATEMENT_LIST
:
1238 tree_stmt_iterator si
;
1241 if (flags
& TDF_SLIM
)
1243 pp_string (buffer
, "<STATEMENT_LIST>");
1247 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
1250 newline_and_indent (buffer
, spc
);
1253 dump_generic_node (buffer
, tsi_stmt (si
), spc
, flags
, true);
1260 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
,
1263 pp_character (buffer
, '=');
1264 if (TREE_CODE (node
) == MODIFY_EXPR
1265 && MOVE_NONTEMPORAL (node
))
1266 pp_string (buffer
, "{nt}");
1268 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
,
1273 pp_string (buffer
, "TARGET_EXPR <");
1274 dump_generic_node (buffer
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
1275 pp_character (buffer
, ',');
1277 dump_generic_node (buffer
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
1278 pp_character (buffer
, '>');
1282 print_declaration (buffer
, DECL_EXPR_DECL (node
), spc
, flags
);
1287 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
1289 pp_string (buffer
, "if (");
1290 dump_generic_node (buffer
, COND_EXPR_COND (node
), spc
, flags
, false);
1291 pp_character (buffer
, ')');
1292 /* The lowered cond_exprs should always be printed in full. */
1293 if (COND_EXPR_THEN (node
)
1294 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
1295 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
1296 && COND_EXPR_ELSE (node
)
1297 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
1298 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
1301 dump_generic_node (buffer
, COND_EXPR_THEN (node
),
1303 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1305 pp_string (buffer
, " else ");
1306 dump_generic_node (buffer
, COND_EXPR_ELSE (node
),
1310 else if (!(flags
& TDF_SLIM
))
1312 /* Output COND_EXPR_THEN. */
1313 if (COND_EXPR_THEN (node
))
1315 newline_and_indent (buffer
, spc
+2);
1316 pp_character (buffer
, '{');
1317 newline_and_indent (buffer
, spc
+4);
1318 dump_generic_node (buffer
, COND_EXPR_THEN (node
), spc
+4,
1320 newline_and_indent (buffer
, spc
+2);
1321 pp_character (buffer
, '}');
1324 /* Output COND_EXPR_ELSE. */
1325 if (COND_EXPR_ELSE (node
)
1326 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1328 newline_and_indent (buffer
, spc
);
1329 pp_string (buffer
, "else");
1330 newline_and_indent (buffer
, spc
+2);
1331 pp_character (buffer
, '{');
1332 newline_and_indent (buffer
, spc
+4);
1333 dump_generic_node (buffer
, COND_EXPR_ELSE (node
), spc
+4,
1335 newline_and_indent (buffer
, spc
+2);
1336 pp_character (buffer
, '}');
1343 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1345 pp_character (buffer
, '?');
1347 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1349 pp_character (buffer
, ':');
1351 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1356 pp_character (buffer
, '{');
1357 if (!(flags
& TDF_SLIM
))
1359 if (BIND_EXPR_VARS (node
))
1361 pp_newline (buffer
);
1363 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= TREE_CHAIN (op0
))
1365 print_declaration (buffer
, op0
, spc
+2, flags
);
1366 pp_newline (buffer
);
1370 newline_and_indent (buffer
, spc
+2);
1371 dump_generic_node (buffer
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
1372 newline_and_indent (buffer
, spc
);
1373 pp_character (buffer
, '}');
1379 print_call_name (buffer
, CALL_EXPR_FN (node
), flags
);
1381 /* Print parameters. */
1383 pp_character (buffer
, '(');
1386 call_expr_arg_iterator iter
;
1387 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
1389 dump_generic_node (buffer
, arg
, spc
, flags
, false);
1390 if (more_call_expr_args_p (&iter
))
1392 pp_character (buffer
, ',');
1397 if (CALL_EXPR_VA_ARG_PACK (node
))
1399 if (call_expr_nargs (node
) > 0)
1401 pp_character (buffer
, ',');
1404 pp_string (buffer
, "__builtin_va_arg_pack ()");
1406 pp_character (buffer
, ')');
1408 op1
= CALL_EXPR_STATIC_CHAIN (node
);
1411 pp_string (buffer
, " [static-chain: ");
1412 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1413 pp_character (buffer
, ']');
1416 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
1417 pp_string (buffer
, " [return slot optimization]");
1418 if (CALL_EXPR_TAILCALL (node
))
1419 pp_string (buffer
, " [tail call]");
1422 case WITH_CLEANUP_EXPR
:
1426 case CLEANUP_POINT_EXPR
:
1427 pp_string (buffer
, "<<cleanup_point ");
1428 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1429 pp_string (buffer
, ">>");
1432 case PLACEHOLDER_EXPR
:
1433 pp_string (buffer
, "<PLACEHOLDER_EXPR ");
1434 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1435 pp_character (buffer
, '>');
1438 /* Binary arithmetic and logic expressions. */
1439 case WIDEN_SUM_EXPR
:
1440 case WIDEN_MULT_EXPR
:
1443 case POINTER_PLUS_EXPR
:
1445 case TRUNC_DIV_EXPR
:
1447 case FLOOR_DIV_EXPR
:
1448 case ROUND_DIV_EXPR
:
1449 case TRUNC_MOD_EXPR
:
1451 case FLOOR_MOD_EXPR
:
1452 case ROUND_MOD_EXPR
:
1454 case EXACT_DIV_EXPR
:
1459 case VEC_LSHIFT_EXPR
:
1460 case VEC_RSHIFT_EXPR
:
1464 case TRUTH_ANDIF_EXPR
:
1465 case TRUTH_ORIF_EXPR
:
1466 case TRUTH_AND_EXPR
:
1468 case TRUTH_XOR_EXPR
:
1482 case UNORDERED_EXPR
:
1484 const char *op
= op_symbol (node
);
1485 op0
= TREE_OPERAND (node
, 0);
1486 op1
= TREE_OPERAND (node
, 1);
1488 /* When the operands are expressions with less priority,
1489 keep semantics of the tree representation. */
1490 if (op_prio (op0
) <= op_prio (node
))
1492 pp_character (buffer
, '(');
1493 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1494 pp_character (buffer
, ')');
1497 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1500 pp_string (buffer
, op
);
1503 /* When the operands are expressions with less priority,
1504 keep semantics of the tree representation. */
1505 if (op_prio (op1
) <= op_prio (node
))
1507 pp_character (buffer
, '(');
1508 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1509 pp_character (buffer
, ')');
1512 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1516 /* Unary arithmetic and logic expressions. */
1519 case TRUTH_NOT_EXPR
:
1521 case PREDECREMENT_EXPR
:
1522 case PREINCREMENT_EXPR
:
1523 case ALIGN_INDIRECT_REF
:
1524 case MISALIGNED_INDIRECT_REF
:
1526 if (TREE_CODE (node
) == ADDR_EXPR
1527 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
1528 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
1529 ; /* Do not output '&' for strings and function pointers. */
1531 pp_string (buffer
, op_symbol (node
));
1533 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1535 pp_character (buffer
, '(');
1536 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1537 pp_character (buffer
, ')');
1540 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1542 if (TREE_CODE (node
) == MISALIGNED_INDIRECT_REF
)
1544 pp_string (buffer
, "{misalignment: ");
1545 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1546 pp_character (buffer
, '}');
1550 case POSTDECREMENT_EXPR
:
1551 case POSTINCREMENT_EXPR
:
1552 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1554 pp_character (buffer
, '(');
1555 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1556 pp_character (buffer
, ')');
1559 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1560 pp_string (buffer
, op_symbol (node
));
1564 pp_string (buffer
, "MIN_EXPR <");
1565 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1566 pp_string (buffer
, ", ");
1567 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1568 pp_character (buffer
, '>');
1572 pp_string (buffer
, "MAX_EXPR <");
1573 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1574 pp_string (buffer
, ", ");
1575 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1576 pp_character (buffer
, '>');
1580 pp_string (buffer
, "ABS_EXPR <");
1581 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1582 pp_character (buffer
, '>');
1589 case ADDR_SPACE_CONVERT_EXPR
:
1590 case FIXED_CONVERT_EXPR
:
1591 case FIX_TRUNC_EXPR
:
1594 type
= TREE_TYPE (node
);
1595 op0
= TREE_OPERAND (node
, 0);
1596 if (type
!= TREE_TYPE (op0
))
1598 pp_character (buffer
, '(');
1599 dump_generic_node (buffer
, type
, spc
, flags
, false);
1600 pp_string (buffer
, ") ");
1602 if (op_prio (op0
) < op_prio (node
))
1603 pp_character (buffer
, '(');
1604 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1605 if (op_prio (op0
) < op_prio (node
))
1606 pp_character (buffer
, ')');
1609 case VIEW_CONVERT_EXPR
:
1610 pp_string (buffer
, "VIEW_CONVERT_EXPR<");
1611 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1612 pp_string (buffer
, ">(");
1613 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1614 pp_character (buffer
, ')');
1618 pp_string (buffer
, "((");
1619 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1620 pp_string (buffer
, "))");
1623 case NON_LVALUE_EXPR
:
1624 pp_string (buffer
, "NON_LVALUE_EXPR <");
1625 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1626 pp_character (buffer
, '>');
1630 pp_string (buffer
, "SAVE_EXPR <");
1631 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1632 pp_character (buffer
, '>');
1636 pp_string (buffer
, "COMPLEX_EXPR <");
1637 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1638 pp_string (buffer
, ", ");
1639 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1640 pp_string (buffer
, ">");
1644 pp_string (buffer
, "CONJ_EXPR <");
1645 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1646 pp_string (buffer
, ">");
1650 pp_string (buffer
, "REALPART_EXPR <");
1651 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1652 pp_string (buffer
, ">");
1656 pp_string (buffer
, "IMAGPART_EXPR <");
1657 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1658 pp_string (buffer
, ">");
1662 pp_string (buffer
, "VA_ARG_EXPR <");
1663 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1664 pp_string (buffer
, ">");
1667 case TRY_FINALLY_EXPR
:
1668 case TRY_CATCH_EXPR
:
1669 pp_string (buffer
, "try");
1670 newline_and_indent (buffer
, spc
+2);
1671 pp_string (buffer
, "{");
1672 newline_and_indent (buffer
, spc
+4);
1673 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
1674 newline_and_indent (buffer
, spc
+2);
1675 pp_string (buffer
, "}");
1676 newline_and_indent (buffer
, spc
);
1678 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
1679 newline_and_indent (buffer
, spc
+2);
1680 pp_string (buffer
, "{");
1681 newline_and_indent (buffer
, spc
+4);
1682 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
1683 newline_and_indent (buffer
, spc
+2);
1684 pp_string (buffer
, "}");
1689 pp_string (buffer
, "catch (");
1690 dump_generic_node (buffer
, CATCH_TYPES (node
), spc
+2, flags
, false);
1691 pp_string (buffer
, ")");
1692 newline_and_indent (buffer
, spc
+2);
1693 pp_string (buffer
, "{");
1694 newline_and_indent (buffer
, spc
+4);
1695 dump_generic_node (buffer
, CATCH_BODY (node
), spc
+4, flags
, true);
1696 newline_and_indent (buffer
, spc
+2);
1697 pp_string (buffer
, "}");
1701 case EH_FILTER_EXPR
:
1702 pp_string (buffer
, "<<<eh_filter (");
1703 dump_generic_node (buffer
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
1704 pp_string (buffer
, ")>>>");
1705 newline_and_indent (buffer
, spc
+2);
1706 pp_string (buffer
, "{");
1707 newline_and_indent (buffer
, spc
+4);
1708 dump_generic_node (buffer
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
1709 newline_and_indent (buffer
, spc
+2);
1710 pp_string (buffer
, "}");
1715 op0
= TREE_OPERAND (node
, 0);
1716 /* If this is for break or continue, don't bother printing it. */
1717 if (DECL_NAME (op0
))
1719 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
1720 if (strcmp (name
, "break") == 0
1721 || strcmp (name
, "continue") == 0)
1724 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1725 pp_character (buffer
, ':');
1726 if (DECL_NONLOCAL (op0
))
1727 pp_string (buffer
, " [non-local]");
1731 pp_string (buffer
, "while (1)");
1732 if (!(flags
& TDF_SLIM
))
1734 newline_and_indent (buffer
, spc
+2);
1735 pp_character (buffer
, '{');
1736 newline_and_indent (buffer
, spc
+4);
1737 dump_generic_node (buffer
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
1738 newline_and_indent (buffer
, spc
+2);
1739 pp_character (buffer
, '}');
1745 pp_string (buffer
, "// predicted ");
1746 if (PREDICT_EXPR_OUTCOME (node
))
1747 pp_string (buffer
, "likely by ");
1749 pp_string (buffer
, "unlikely by ");
1750 pp_string (buffer
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
1751 pp_string (buffer
, " predictor.");
1755 pp_string (buffer
, "return");
1756 op0
= TREE_OPERAND (node
, 0);
1760 if (TREE_CODE (op0
) == MODIFY_EXPR
)
1761 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1),
1764 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1769 pp_string (buffer
, "if (");
1770 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1771 pp_string (buffer
, ") break");
1775 pp_string (buffer
, "switch (");
1776 dump_generic_node (buffer
, SWITCH_COND (node
), spc
, flags
, false);
1777 pp_character (buffer
, ')');
1778 if (!(flags
& TDF_SLIM
))
1780 newline_and_indent (buffer
, spc
+2);
1781 pp_character (buffer
, '{');
1782 if (SWITCH_BODY (node
))
1784 newline_and_indent (buffer
, spc
+4);
1785 dump_generic_node (buffer
, SWITCH_BODY (node
), spc
+4, flags
,
1790 tree vec
= SWITCH_LABELS (node
);
1791 size_t i
, n
= TREE_VEC_LENGTH (vec
);
1792 for (i
= 0; i
< n
; ++i
)
1794 tree elt
= TREE_VEC_ELT (vec
, i
);
1795 newline_and_indent (buffer
, spc
+4);
1798 dump_generic_node (buffer
, elt
, spc
+4, flags
, false);
1799 pp_string (buffer
, " goto ");
1800 dump_generic_node (buffer
, CASE_LABEL (elt
), spc
+4,
1802 pp_semicolon (buffer
);
1805 pp_string (buffer
, "case ???: goto ???;");
1808 newline_and_indent (buffer
, spc
+2);
1809 pp_character (buffer
, '}');
1815 op0
= GOTO_DESTINATION (node
);
1816 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
1818 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
1819 if (strcmp (name
, "break") == 0
1820 || strcmp (name
, "continue") == 0)
1822 pp_string (buffer
, name
);
1826 pp_string (buffer
, "goto ");
1827 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1831 pp_string (buffer
, "__asm__");
1832 if (ASM_VOLATILE_P (node
))
1833 pp_string (buffer
, " __volatile__");
1834 pp_character (buffer
, '(');
1835 dump_generic_node (buffer
, ASM_STRING (node
), spc
, flags
, false);
1836 pp_character (buffer
, ':');
1837 dump_generic_node (buffer
, ASM_OUTPUTS (node
), spc
, flags
, false);
1838 pp_character (buffer
, ':');
1839 dump_generic_node (buffer
, ASM_INPUTS (node
), spc
, flags
, false);
1840 if (ASM_CLOBBERS (node
))
1842 pp_character (buffer
, ':');
1843 dump_generic_node (buffer
, ASM_CLOBBERS (node
), spc
, flags
, false);
1845 pp_string (buffer
, ")");
1848 case CASE_LABEL_EXPR
:
1849 if (CASE_LOW (node
) && CASE_HIGH (node
))
1851 pp_string (buffer
, "case ");
1852 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
1853 pp_string (buffer
, " ... ");
1854 dump_generic_node (buffer
, CASE_HIGH (node
), spc
, flags
, false);
1856 else if (CASE_LOW (node
))
1858 pp_string (buffer
, "case ");
1859 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
1862 pp_string (buffer
, "default");
1863 pp_character (buffer
, ':');
1867 pp_string (buffer
, "OBJ_TYPE_REF(");
1868 dump_generic_node (buffer
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
1869 pp_character (buffer
, ';');
1870 dump_generic_node (buffer
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
1871 pp_character (buffer
, '-');
1872 pp_character (buffer
, '>');
1873 dump_generic_node (buffer
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
1874 pp_character (buffer
, ')');
1878 dump_generic_node (buffer
, SSA_NAME_VAR (node
), spc
, flags
, false);
1879 pp_string (buffer
, "_");
1880 pp_decimal_int (buffer
, SSA_NAME_VERSION (node
));
1881 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
1882 pp_string (buffer
, "(ab)");
1883 else if (SSA_NAME_IS_DEFAULT_DEF (node
))
1884 pp_string (buffer
, "(D)");
1887 case WITH_SIZE_EXPR
:
1888 pp_string (buffer
, "WITH_SIZE_EXPR <");
1889 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1890 pp_string (buffer
, ", ");
1891 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1892 pp_string (buffer
, ">");
1896 pp_string (buffer
, "ASSERT_EXPR <");
1897 dump_generic_node (buffer
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
1898 pp_string (buffer
, ", ");
1899 dump_generic_node (buffer
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
1900 pp_string (buffer
, ">");
1904 pp_string (buffer
, "scev_known");
1907 case SCEV_NOT_KNOWN
:
1908 pp_string (buffer
, "scev_not_known");
1911 case POLYNOMIAL_CHREC
:
1912 pp_string (buffer
, "{");
1913 dump_generic_node (buffer
, CHREC_LEFT (node
), spc
, flags
, false);
1914 pp_string (buffer
, ", +, ");
1915 dump_generic_node (buffer
, CHREC_RIGHT (node
), spc
, flags
, false);
1916 pp_string (buffer
, "}_");
1917 dump_generic_node (buffer
, CHREC_VAR (node
), spc
, flags
, false);
1921 case REALIGN_LOAD_EXPR
:
1922 pp_string (buffer
, "REALIGN_LOAD <");
1923 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1924 pp_string (buffer
, ", ");
1925 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1926 pp_string (buffer
, ", ");
1927 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1928 pp_string (buffer
, ">");
1932 pp_string (buffer
, " VEC_COND_EXPR < ");
1933 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1934 pp_string (buffer
, " , ");
1935 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1936 pp_string (buffer
, " , ");
1937 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1938 pp_string (buffer
, " > ");
1942 pp_string (buffer
, " DOT_PROD_EXPR < ");
1943 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1944 pp_string (buffer
, ", ");
1945 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1946 pp_string (buffer
, ", ");
1947 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1948 pp_string (buffer
, " > ");
1952 pp_string (buffer
, "#pragma omp parallel");
1953 dump_omp_clauses (buffer
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
1956 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
1958 newline_and_indent (buffer
, spc
+ 2);
1959 pp_character (buffer
, '{');
1960 newline_and_indent (buffer
, spc
+ 4);
1961 dump_generic_node (buffer
, OMP_BODY (node
), spc
+ 4, flags
, false);
1962 newline_and_indent (buffer
, spc
+ 2);
1963 pp_character (buffer
, '}');
1969 pp_string (buffer
, "#pragma omp task");
1970 dump_omp_clauses (buffer
, OMP_TASK_CLAUSES (node
), spc
, flags
);
1974 pp_string (buffer
, "#pragma omp for");
1975 dump_omp_clauses (buffer
, OMP_FOR_CLAUSES (node
), spc
, flags
);
1977 if (!(flags
& TDF_SLIM
))
1981 if (OMP_FOR_PRE_BODY (node
))
1983 newline_and_indent (buffer
, spc
+ 2);
1984 pp_character (buffer
, '{');
1986 newline_and_indent (buffer
, spc
);
1987 dump_generic_node (buffer
, OMP_FOR_PRE_BODY (node
),
1991 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
1994 newline_and_indent (buffer
, spc
);
1995 pp_string (buffer
, "for (");
1996 dump_generic_node (buffer
, TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
1998 pp_string (buffer
, "; ");
1999 dump_generic_node (buffer
, TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
2001 pp_string (buffer
, "; ");
2002 dump_generic_node (buffer
, TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
2004 pp_string (buffer
, ")");
2006 if (OMP_FOR_BODY (node
))
2008 newline_and_indent (buffer
, spc
+ 2);
2009 pp_character (buffer
, '{');
2010 newline_and_indent (buffer
, spc
+ 4);
2011 dump_generic_node (buffer
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
2013 newline_and_indent (buffer
, spc
+ 2);
2014 pp_character (buffer
, '}');
2016 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
2017 if (OMP_FOR_PRE_BODY (node
))
2020 newline_and_indent (buffer
, spc
+ 2);
2021 pp_character (buffer
, '}');
2028 pp_string (buffer
, "#pragma omp sections");
2029 dump_omp_clauses (buffer
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
2033 pp_string (buffer
, "#pragma omp section");
2037 pp_string (buffer
, "#pragma omp master");
2041 pp_string (buffer
, "#pragma omp ordered");
2045 pp_string (buffer
, "#pragma omp critical");
2046 if (OMP_CRITICAL_NAME (node
))
2049 pp_character (buffer
, '(');
2050 dump_generic_node (buffer
, OMP_CRITICAL_NAME (node
), spc
,
2052 pp_character (buffer
, ')');
2057 pp_string (buffer
, "#pragma omp atomic");
2058 newline_and_indent (buffer
, spc
+ 2);
2059 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2061 pp_character (buffer
, '=');
2063 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2067 pp_string (buffer
, "#pragma omp single");
2068 dump_omp_clauses (buffer
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
2072 dump_omp_clause (buffer
, node
, spc
, flags
);
2076 case REDUC_MAX_EXPR
:
2077 pp_string (buffer
, " REDUC_MAX_EXPR < ");
2078 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2079 pp_string (buffer
, " > ");
2082 case REDUC_MIN_EXPR
:
2083 pp_string (buffer
, " REDUC_MIN_EXPR < ");
2084 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2085 pp_string (buffer
, " > ");
2088 case REDUC_PLUS_EXPR
:
2089 pp_string (buffer
, " REDUC_PLUS_EXPR < ");
2090 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2091 pp_string (buffer
, " > ");
2094 case VEC_WIDEN_MULT_HI_EXPR
:
2095 pp_string (buffer
, " VEC_WIDEN_MULT_HI_EXPR < ");
2096 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2097 pp_string (buffer
, ", ");
2098 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2099 pp_string (buffer
, " > ");
2102 case VEC_WIDEN_MULT_LO_EXPR
:
2103 pp_string (buffer
, " VEC_WIDEN_MULT_LO_EXPR < ");
2104 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2105 pp_string (buffer
, ", ");
2106 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2107 pp_string (buffer
, " > ");
2110 case VEC_UNPACK_HI_EXPR
:
2111 pp_string (buffer
, " VEC_UNPACK_HI_EXPR < ");
2112 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2113 pp_string (buffer
, " > ");
2116 case VEC_UNPACK_LO_EXPR
:
2117 pp_string (buffer
, " VEC_UNPACK_LO_EXPR < ");
2118 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2119 pp_string (buffer
, " > ");
2122 case VEC_UNPACK_FLOAT_HI_EXPR
:
2123 pp_string (buffer
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2124 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2125 pp_string (buffer
, " > ");
2128 case VEC_UNPACK_FLOAT_LO_EXPR
:
2129 pp_string (buffer
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2130 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2131 pp_string (buffer
, " > ");
2134 case VEC_PACK_TRUNC_EXPR
:
2135 pp_string (buffer
, " VEC_PACK_TRUNC_EXPR < ");
2136 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2137 pp_string (buffer
, ", ");
2138 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2139 pp_string (buffer
, " > ");
2142 case VEC_PACK_SAT_EXPR
:
2143 pp_string (buffer
, " VEC_PACK_SAT_EXPR < ");
2144 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2145 pp_string (buffer
, ", ");
2146 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2147 pp_string (buffer
, " > ");
2150 case VEC_PACK_FIX_TRUNC_EXPR
:
2151 pp_string (buffer
, " VEC_PACK_FIX_TRUNC_EXPR < ");
2152 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2153 pp_string (buffer
, ", ");
2154 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2155 pp_string (buffer
, " > ");
2159 dump_block_node (buffer
, node
, spc
, flags
);
2162 case VEC_EXTRACT_EVEN_EXPR
:
2163 pp_string (buffer
, " VEC_EXTRACT_EVEN_EXPR < ");
2164 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2165 pp_string (buffer
, ", ");
2166 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2167 pp_string (buffer
, " > ");
2170 case VEC_EXTRACT_ODD_EXPR
:
2171 pp_string (buffer
, " VEC_EXTRACT_ODD_EXPR < ");
2172 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2173 pp_string (buffer
, ", ");
2174 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2175 pp_string (buffer
, " > ");
2178 case VEC_INTERLEAVE_HIGH_EXPR
:
2179 pp_string (buffer
, " VEC_INTERLEAVE_HIGH_EXPR < ");
2180 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2181 pp_string (buffer
, ", ");
2182 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2183 pp_string (buffer
, " > ");
2186 case VEC_INTERLEAVE_LOW_EXPR
:
2187 pp_string (buffer
, " VEC_INTERLEAVE_LOW_EXPR < ");
2188 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2189 pp_string (buffer
, ", ");
2190 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2191 pp_string (buffer
, " > ");
2198 if (is_stmt
&& is_expr
)
2199 pp_semicolon (buffer
);
2201 /* If we're building a diagnostic, the formatted text will be written
2202 into BUFFER's stream by the caller; otherwise, write it now. */
2203 if (!(flags
& TDF_DIAGNOSTIC
))
2204 pp_write_text_to_stream (buffer
);
2209 /* Print the declaration of a variable. */
2212 print_declaration (pretty_printer
*buffer
, tree t
, int spc
, int flags
)
2216 if (TREE_CODE (t
) == TYPE_DECL
)
2217 pp_string (buffer
, "typedef ");
2219 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
2220 pp_string (buffer
, "register ");
2222 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
2223 pp_string (buffer
, "extern ");
2224 else if (TREE_STATIC (t
))
2225 pp_string (buffer
, "static ");
2227 /* Print the type and name. */
2228 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
2232 /* Print array's type. */
2233 tmp
= TREE_TYPE (t
);
2234 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
2235 tmp
= TREE_TYPE (tmp
);
2236 dump_generic_node (buffer
, TREE_TYPE (tmp
), spc
, flags
, false);
2238 /* Print variable's name. */
2240 dump_generic_node (buffer
, t
, spc
, flags
, false);
2242 /* Print the dimensions. */
2243 tmp
= TREE_TYPE (t
);
2244 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
2246 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
2247 tmp
= TREE_TYPE (tmp
);
2250 else if (TREE_CODE (t
) == FUNCTION_DECL
)
2252 dump_generic_node (buffer
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
2254 dump_decl_name (buffer
, t
, flags
);
2255 dump_function_declaration (buffer
, TREE_TYPE (t
), spc
, flags
);
2259 /* Print type declaration. */
2260 dump_generic_node (buffer
, TREE_TYPE (t
), spc
, flags
, false);
2262 /* Print variable's name. */
2264 dump_generic_node (buffer
, t
, spc
, flags
, false);
2267 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
2269 pp_string (buffer
, " __asm__ ");
2270 pp_character (buffer
, '(');
2271 dump_generic_node (buffer
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
2272 pp_character (buffer
, ')');
2275 /* The initial value of a function serves to determine whether the function
2276 is declared or defined. So the following does not apply to function
2278 if (TREE_CODE (t
) != FUNCTION_DECL
)
2280 /* Print the initial value. */
2281 if (DECL_INITIAL (t
))
2284 pp_character (buffer
, '=');
2286 dump_generic_node (buffer
, DECL_INITIAL (t
), spc
, flags
, false);
2290 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
2292 pp_string (buffer
, " [value-expr: ");
2293 dump_generic_node (buffer
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
2294 pp_character (buffer
, ']');
2297 pp_character (buffer
, ';');
2301 /* Prints a structure: name, fields, and methods.
2302 FIXME: Still incomplete. */
2305 print_struct_decl (pretty_printer
*buffer
, const_tree node
, int spc
, int flags
)
2307 /* Print the name of the structure. */
2308 if (TYPE_NAME (node
))
2311 if (TREE_CODE (node
) == RECORD_TYPE
)
2312 pp_string (buffer
, "struct ");
2313 else if ((TREE_CODE (node
) == UNION_TYPE
2314 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
2315 pp_string (buffer
, "union ");
2317 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, 0, false);
2320 /* Print the contents of the structure. */
2321 pp_newline (buffer
);
2323 pp_character (buffer
, '{');
2324 pp_newline (buffer
);
2326 /* Print the fields of the structure. */
2329 tmp
= TYPE_FIELDS (node
);
2332 /* Avoid to print recursively the structure. */
2333 /* FIXME : Not implemented correctly...,
2334 what about the case when we have a cycle in the contain graph? ...
2335 Maybe this could be solved by looking at the scope in which the
2336 structure was declared. */
2337 if (TREE_TYPE (tmp
) != node
2338 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
2339 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
2341 print_declaration (buffer
, tmp
, spc
+2, flags
);
2342 pp_newline (buffer
);
2344 tmp
= TREE_CHAIN (tmp
);
2348 pp_character (buffer
, '}');
2351 /* Return the priority of the operator CODE.
2353 From lowest to highest precedence with either left-to-right (L-R)
2354 or right-to-left (R-L) associativity]:
2357 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2369 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2370 15 [L-R] fn() [] -> .
2372 unary +, - and * have higher precedence than the corresponding binary
2376 op_code_prio (enum tree_code code
)
2393 case TRUTH_ORIF_EXPR
:
2396 case TRUTH_AND_EXPR
:
2397 case TRUTH_ANDIF_EXPR
:
2404 case TRUTH_XOR_EXPR
:
2421 case UNORDERED_EXPR
:
2434 case WIDEN_SUM_EXPR
:
2436 case POINTER_PLUS_EXPR
:
2440 case VEC_WIDEN_MULT_HI_EXPR
:
2441 case VEC_WIDEN_MULT_LO_EXPR
:
2442 case WIDEN_MULT_EXPR
:
2445 case TRUNC_DIV_EXPR
:
2447 case FLOOR_DIV_EXPR
:
2448 case ROUND_DIV_EXPR
:
2450 case EXACT_DIV_EXPR
:
2451 case TRUNC_MOD_EXPR
:
2453 case FLOOR_MOD_EXPR
:
2454 case ROUND_MOD_EXPR
:
2457 case TRUTH_NOT_EXPR
:
2459 case POSTINCREMENT_EXPR
:
2460 case POSTDECREMENT_EXPR
:
2461 case PREINCREMENT_EXPR
:
2462 case PREDECREMENT_EXPR
:
2464 case ALIGN_INDIRECT_REF
:
2465 case MISALIGNED_INDIRECT_REF
:
2470 case FIX_TRUNC_EXPR
:
2476 case ARRAY_RANGE_REF
:
2480 /* Special expressions. */
2486 case REDUC_MAX_EXPR
:
2487 case REDUC_MIN_EXPR
:
2488 case REDUC_PLUS_EXPR
:
2489 case VEC_LSHIFT_EXPR
:
2490 case VEC_RSHIFT_EXPR
:
2491 case VEC_UNPACK_HI_EXPR
:
2492 case VEC_UNPACK_LO_EXPR
:
2493 case VEC_UNPACK_FLOAT_HI_EXPR
:
2494 case VEC_UNPACK_FLOAT_LO_EXPR
:
2495 case VEC_PACK_TRUNC_EXPR
:
2496 case VEC_PACK_SAT_EXPR
:
2500 /* Return an arbitrarily high precedence to avoid surrounding single
2501 VAR_DECLs in ()s. */
2506 /* Return the priority of the operator OP. */
2509 op_prio (const_tree op
)
2511 enum tree_code code
;
2516 code
= TREE_CODE (op
);
2517 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
2518 return op_prio (TREE_OPERAND (op
, 0));
2520 return op_code_prio (code
);
2523 /* Return the symbol associated with operator CODE. */
2526 op_symbol_code (enum tree_code code
)
2534 case TRUTH_ORIF_EXPR
:
2537 case TRUTH_AND_EXPR
:
2538 case TRUTH_ANDIF_EXPR
:
2544 case TRUTH_XOR_EXPR
:
2554 case UNORDERED_EXPR
:
2600 case VEC_LSHIFT_EXPR
:
2603 case VEC_RSHIFT_EXPR
:
2606 case POINTER_PLUS_EXPR
:
2612 case REDUC_PLUS_EXPR
:
2615 case WIDEN_SUM_EXPR
:
2618 case WIDEN_MULT_EXPR
:
2628 case TRUTH_NOT_EXPR
:
2635 case ALIGN_INDIRECT_REF
:
2638 case MISALIGNED_INDIRECT_REF
:
2641 case TRUNC_DIV_EXPR
:
2648 case FLOOR_DIV_EXPR
:
2651 case ROUND_DIV_EXPR
:
2654 case EXACT_DIV_EXPR
:
2657 case TRUNC_MOD_EXPR
:
2663 case FLOOR_MOD_EXPR
:
2666 case ROUND_MOD_EXPR
:
2669 case PREDECREMENT_EXPR
:
2672 case PREINCREMENT_EXPR
:
2675 case POSTDECREMENT_EXPR
:
2678 case POSTINCREMENT_EXPR
:
2688 return "<<< ??? >>>";
2692 /* Return the symbol associated with operator OP. */
2695 op_symbol (const_tree op
)
2697 return op_symbol_code (TREE_CODE (op
));
2700 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
2701 the gimple_call_fn of a GIMPLE_CALL. */
2704 print_call_name (pretty_printer
*buffer
, tree node
, int flags
)
2708 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
2709 op0
= TREE_OPERAND (op0
, 0);
2712 switch (TREE_CODE (op0
))
2717 dump_function_name (buffer
, op0
, flags
);
2723 op0
= TREE_OPERAND (op0
, 0);
2727 pp_string (buffer
, "(");
2728 dump_generic_node (buffer
, TREE_OPERAND (op0
, 0), 0, flags
, false);
2729 pp_string (buffer
, ") ? ");
2730 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1), 0, flags
, false);
2731 pp_string (buffer
, " : ");
2732 dump_generic_node (buffer
, TREE_OPERAND (op0
, 2), 0, flags
, false);
2736 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
2737 dump_function_name (buffer
, TREE_OPERAND (op0
, 0), flags
);
2739 dump_generic_node (buffer
, op0
, 0, flags
, false);
2745 dump_generic_node (buffer
, op0
, 0, flags
, false);
2753 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2756 pretty_print_string (pretty_printer
*buffer
, const char *str
)
2766 pp_string (buffer
, "\\b");
2770 pp_string (buffer
, "\\f");
2774 pp_string (buffer
, "\\n");
2778 pp_string (buffer
, "\\r");
2782 pp_string (buffer
, "\\t");
2786 pp_string (buffer
, "\\v");
2790 pp_string (buffer
, "\\\\");
2794 pp_string (buffer
, "\\\"");
2798 pp_string (buffer
, "\\'");
2801 /* No need to handle \0; the loop terminates on \0. */
2804 pp_string (buffer
, "\\1");
2808 pp_string (buffer
, "\\2");
2812 pp_string (buffer
, "\\3");
2816 pp_string (buffer
, "\\4");
2820 pp_string (buffer
, "\\5");
2824 pp_string (buffer
, "\\6");
2828 pp_string (buffer
, "\\7");
2832 pp_character (buffer
, str
[0]);
2840 maybe_init_pretty_print (FILE *file
)
2844 pp_construct (&buffer
, /* prefix */NULL
, /* line-width */0);
2845 pp_needs_newline (&buffer
) = true;
2846 pp_translate_identifiers (&buffer
) = false;
2850 buffer
.buffer
->stream
= file
;
2854 newline_and_indent (pretty_printer
*buffer
, int spc
)
2856 pp_newline (buffer
);
2860 /* Handle a %K format for TEXT. Separate from default_tree_printer so
2861 it can also be used in front ends.
2862 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
2866 percent_K_format (text_info
*text
)
2868 tree t
= va_arg (*text
->args_ptr
, tree
), block
;
2869 gcc_assert (text
->locus
!= NULL
);
2870 *text
->locus
= EXPR_LOCATION (t
);
2871 gcc_assert (pp_ti_abstract_origin (text
) != NULL
);
2872 block
= TREE_BLOCK (t
);
2873 *pp_ti_abstract_origin (text
) = NULL
;
2875 && TREE_CODE (block
) == BLOCK
2876 && BLOCK_ABSTRACT_ORIGIN (block
))
2878 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
2880 while (TREE_CODE (ao
) == BLOCK
2881 && BLOCK_ABSTRACT_ORIGIN (ao
)
2882 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
2883 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
2885 if (TREE_CODE (ao
) == FUNCTION_DECL
)
2887 *pp_ti_abstract_origin (text
) = block
;
2890 block
= BLOCK_SUPERCONTEXT (block
);
2894 /* Print the identifier ID to PRETTY-PRINTER. */
2897 pp_base_tree_identifier (pretty_printer
*pp
, tree id
)
2899 if (pp_translate_identifiers (pp
))
2901 const char *text
= identifier_to_locale (IDENTIFIER_POINTER (id
));
2902 pp_append_text (pp
, text
, text
+ strlen (text
));
2905 pp_append_text (pp
, IDENTIFIER_POINTER (id
),
2906 IDENTIFIER_POINTER (id
) + IDENTIFIER_LENGTH (id
));