1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005 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 2, 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 COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
27 #include "diagnostic.h"
30 #include "tree-flow.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
33 #include "tree-chrec.h"
35 /* Local functions, macros and variables. */
36 static int op_prio (tree
);
37 static const char *op_symbol (tree
);
38 static void pretty_print_string (pretty_printer
*, const char*);
39 static void print_call_name (pretty_printer
*, tree
);
40 static void newline_and_indent (pretty_printer
*, int);
41 static void maybe_init_pretty_print (FILE *);
42 static void print_declaration (pretty_printer
*, tree
, int, int);
43 static void print_struct_decl (pretty_printer
*, tree
, int, int);
44 static void do_niy (pretty_printer
*, tree
);
45 static void dump_vops (pretty_printer
*, tree
, int, int);
46 static void dump_generic_bb_buff (pretty_printer
*, basic_block
, int, int);
48 #define INDENT(SPACE) do { \
49 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
51 #define NIY do_niy(buffer,node)
53 #define PRINT_FUNCTION_NAME(NODE) pp_printf \
54 (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \
55 lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
56 lang_hooks.decl_printable_name (NODE, 1))
58 static pretty_printer buffer
;
59 static int initialized
= 0;
60 static bool dumping_stmts
;
62 /* Try to print something for an unknown tree code. */
65 do_niy (pretty_printer
*buffer
, tree node
)
69 pp_string (buffer
, "<<< Unknown tree: ");
70 pp_string (buffer
, tree_code_name
[(int) TREE_CODE (node
)]);
74 len
= TREE_CODE_LENGTH (TREE_CODE (node
));
75 for (i
= 0; i
< len
; ++i
)
77 newline_and_indent (buffer
, 2);
78 dump_generic_node (buffer
, TREE_OPERAND (node
, i
), 2, 0, false);
82 pp_string (buffer
, " >>>\n");
86 debug_generic_expr (tree t
)
88 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_UID
);
89 fprintf (stderr
, "\n");
93 debug_generic_stmt (tree t
)
95 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_UID
);
96 fprintf (stderr
, "\n");
99 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
101 print_generic_decl (FILE *file
, tree decl
, int flags
)
103 maybe_init_pretty_print (file
);
104 dumping_stmts
= true;
105 print_declaration (&buffer
, decl
, 2, flags
);
106 pp_write_text_to_stream (&buffer
);
109 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
110 to show in the dump. See TDF_* in tree.h. */
113 print_generic_stmt (FILE *file
, tree t
, int flags
)
115 maybe_init_pretty_print (file
);
116 dumping_stmts
= true;
117 dump_generic_node (&buffer
, t
, 0, flags
, true);
121 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
122 to show in the dump. See TDF_* in tree.h. The output is indented by
126 print_generic_stmt_indented (FILE *file
, tree t
, int flags
, int indent
)
130 maybe_init_pretty_print (file
);
131 dumping_stmts
= true;
133 for (i
= 0; i
< indent
; i
++)
135 dump_generic_node (&buffer
, t
, indent
, flags
, true);
139 /* Print a single expression T on file FILE. FLAGS specifies details to show
140 in the dump. See TDF_* in tree.h. */
143 print_generic_expr (FILE *file
, tree t
, int flags
)
145 maybe_init_pretty_print (file
);
146 dumping_stmts
= false;
147 dump_generic_node (&buffer
, t
, 0, flags
, false);
150 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
154 dump_decl_name (pretty_printer
*buffer
, tree node
, int flags
)
156 if (DECL_NAME (node
))
157 pp_tree_identifier (buffer
, DECL_NAME (node
));
159 if ((flags
& TDF_UID
)
160 || DECL_NAME (node
) == NULL_TREE
)
162 if (TREE_CODE (node
) == LABEL_DECL
163 && LABEL_DECL_UID (node
) != -1)
164 pp_printf (buffer
, "L." HOST_WIDE_INT_PRINT_DEC
,
165 LABEL_DECL_UID (node
));
168 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
169 pp_printf (buffer
, "%c.%u", c
, DECL_UID (node
));
174 /* Like the above, but used for pretty printing function calls. */
177 dump_function_name (pretty_printer
*buffer
, tree node
)
179 if (DECL_NAME (node
))
180 PRINT_FUNCTION_NAME (node
);
182 dump_decl_name (buffer
, node
, 0);
185 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
186 FLAGS are as in dump_generic_node. */
189 dump_function_declaration (pretty_printer
*buffer
, tree node
,
192 bool wrote_arg
= false;
196 pp_character (buffer
, '(');
198 /* Print the argument types. The last element in the list is a VOID_TYPE.
199 The following avoids printing the last element. */
200 arg
= TYPE_ARG_TYPES (node
);
201 while (arg
&& TREE_CHAIN (arg
) && arg
!= error_mark_node
)
204 dump_generic_node (buffer
, TREE_VALUE (arg
), spc
, flags
, false);
205 arg
= TREE_CHAIN (arg
);
206 if (TREE_CHAIN (arg
) && TREE_CODE (TREE_CHAIN (arg
)) == TREE_LIST
)
208 pp_character (buffer
, ',');
214 pp_string (buffer
, "void");
216 pp_character (buffer
, ')');
219 /* Dump the domain associated with an array. */
222 dump_array_domain (pretty_printer
*buffer
, tree domain
, int spc
, int flags
)
224 pp_character (buffer
, '[');
227 tree min
= TYPE_MIN_VALUE (domain
);
228 tree max
= TYPE_MAX_VALUE (domain
);
231 && integer_zerop (min
)
232 && host_integerp (max
, 0))
233 pp_wide_integer (buffer
, TREE_INT_CST_LOW (max
) + 1);
237 dump_generic_node (buffer
, min
, spc
, flags
, false);
238 pp_character (buffer
, ':');
240 dump_generic_node (buffer
, max
, spc
, flags
, false);
244 pp_string (buffer
, "<unknown>");
245 pp_character (buffer
, ']');
248 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
249 FLAGS specifies details to show in the dump (see TDF_* in tree.h). If
250 IS_STMT is true, the object printed is considered to be a statement
251 and it is terminated by ';' if appropriate. */
254 dump_generic_node (pretty_printer
*buffer
, tree node
, int spc
, int flags
,
262 if (node
== NULL_TREE
)
265 is_expr
= EXPR_P (node
);
267 if (TREE_CODE (node
) != ERROR_MARK
268 && is_gimple_stmt (node
)
269 && (flags
& TDF_VOPS
)
271 dump_vops (buffer
, node
, spc
, flags
);
273 if (is_stmt
&& (flags
& TDF_STMTADDR
))
274 pp_printf (buffer
, "<&%p> ", (void *)node
);
277 && (flags
& TDF_LINENO
)
278 && EXPR_HAS_LOCATION (node
))
280 expanded_location xloc
= expand_location (EXPR_LOCATION (node
));
281 pp_character (buffer
, '[');
284 pp_string (buffer
, xloc
.file
);
285 pp_string (buffer
, " : ");
287 pp_decimal_int (buffer
, xloc
.line
);
288 pp_string (buffer
, "] ");
291 switch (TREE_CODE (node
))
294 pp_string (buffer
, "<<< error >>>");
297 case IDENTIFIER_NODE
:
298 pp_tree_identifier (buffer
, node
);
302 while (node
&& node
!= error_mark_node
)
304 if (TREE_PURPOSE (node
))
306 dump_generic_node (buffer
, TREE_PURPOSE (node
), spc
, flags
, false);
309 dump_generic_node (buffer
, TREE_VALUE (node
), spc
, flags
, false);
310 node
= TREE_CHAIN (node
);
311 if (node
&& TREE_CODE (node
) == TREE_LIST
)
313 pp_character (buffer
, ',');
320 dump_generic_node (buffer
, BINFO_TYPE (node
), spc
, flags
, false);
325 if (TREE_VEC_LENGTH (node
) > 0)
327 size_t len
= TREE_VEC_LENGTH (node
);
328 for (i
= 0; i
< len
- 1; i
++)
330 dump_generic_node (buffer
, TREE_VEC_ELT (node
, i
), spc
, flags
,
332 pp_character (buffer
, ',');
335 dump_generic_node (buffer
, TREE_VEC_ELT (node
, len
- 1), spc
,
354 unsigned int quals
= TYPE_QUALS (node
);
355 enum tree_code_class
class;
357 if (quals
& TYPE_QUAL_CONST
)
358 pp_string (buffer
, "const ");
359 else if (quals
& TYPE_QUAL_VOLATILE
)
360 pp_string (buffer
, "volatile ");
361 else if (quals
& TYPE_QUAL_RESTRICT
)
362 pp_string (buffer
, "restrict ");
364 class = TREE_CODE_CLASS (TREE_CODE (node
));
366 if (class == tcc_declaration
)
368 if (DECL_NAME (node
))
369 dump_decl_name (buffer
, node
, flags
);
371 pp_string (buffer
, "<unnamed type decl>");
373 else if (class == tcc_type
)
375 if (TYPE_NAME (node
))
377 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
378 pp_tree_identifier (buffer
, TYPE_NAME (node
));
379 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
380 && DECL_NAME (TYPE_NAME (node
)))
381 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
383 pp_string (buffer
, "<unnamed type>");
385 else if (TREE_CODE (node
) == VECTOR_TYPE
)
387 pp_string (buffer
, "vector ");
388 dump_generic_node (buffer
, TREE_TYPE (node
),
392 pp_string (buffer
, "<unnamed type>");
399 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
401 if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
403 tree fnode
= TREE_TYPE (node
);
405 dump_generic_node (buffer
, TREE_TYPE (fnode
), spc
, flags
, false);
407 pp_character (buffer
, '(');
408 pp_string (buffer
, str
);
409 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
410 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
412 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
414 pp_character (buffer
, ')');
415 dump_function_declaration (buffer
, fnode
, spc
, flags
);
419 unsigned int quals
= TYPE_QUALS (node
);
421 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
423 pp_string (buffer
, str
);
425 if (quals
& TYPE_QUAL_CONST
)
426 pp_string (buffer
, " const");
427 else if (quals
& TYPE_QUAL_VOLATILE
)
428 pp_string (buffer
, "volatile");
429 else if (quals
& TYPE_QUAL_RESTRICT
)
430 pp_string (buffer
, " restrict");
432 if (TYPE_REF_CAN_ALIAS_ALL (node
))
433 pp_string (buffer
, " {ref-all}");
442 dump_decl_name (buffer
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)), flags
);
443 pp_string (buffer
, "::");
448 const char *sep
= "";
451 pp_string (buffer
, "MEM[");
453 tmp
= TMR_SYMBOL (node
);
456 pp_string (buffer
, sep
);
458 pp_string (buffer
, "symbol: ");
459 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
461 tmp
= TMR_BASE (node
);
464 pp_string (buffer
, sep
);
466 pp_string (buffer
, "base: ");
467 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
469 tmp
= TMR_INDEX (node
);
472 pp_string (buffer
, sep
);
474 pp_string (buffer
, "index: ");
475 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
477 tmp
= TMR_STEP (node
);
480 pp_string (buffer
, sep
);
482 pp_string (buffer
, "step: ");
483 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
485 tmp
= TMR_OFFSET (node
);
488 pp_string (buffer
, sep
);
490 pp_string (buffer
, "offset: ");
491 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
493 pp_string (buffer
, "]");
494 if (flags
& TDF_DETAILS
)
496 pp_string (buffer
, "{");
497 dump_generic_node (buffer
, TMR_ORIGINAL (node
), spc
, flags
,
499 pp_string (buffer
, "}");
508 /* Print the innermost component type. */
509 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
510 tmp
= TREE_TYPE (tmp
))
512 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
514 /* Print the dimensions. */
515 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
516 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
522 case QUAL_UNION_TYPE
:
523 /* Print the name of the structure. */
524 if (TREE_CODE (node
) == RECORD_TYPE
)
525 pp_string (buffer
, "struct ");
526 else if (TREE_CODE (node
) == UNION_TYPE
)
527 pp_string (buffer
, "union ");
529 if (TYPE_NAME (node
))
530 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, flags
, false);
532 print_struct_decl (buffer
, node
, spc
, flags
);
540 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
542 /* In the case of a pointer, one may want to divide by the
543 size of the pointed-to type. Unfortunately, this not
544 straightforward. The C front-end maps expressions
549 in such a way that the two INTEGER_CST nodes for "5" have
550 different values but identical types. In the latter
551 case, the 5 is multiplied by sizeof (int) in c-common.c
552 (pointer_int_sum) to convert it to a byte address, and
553 yet the type of the node is left unchanged. Argh. What
554 is consistent though is that the number value corresponds
555 to bytes (UNITS) offset.
557 NB: Neither of the following divisors can be trivially
558 used to recover the original literal:
560 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
561 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
562 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
563 pp_string (buffer
, "B"); /* pseudo-unit */
565 else if (! host_integerp (node
, 0))
569 if (tree_int_cst_sgn (val
) < 0)
571 pp_character (buffer
, '-');
572 val
= build_int_cst_wide (NULL_TREE
,
573 -TREE_INT_CST_LOW (val
),
574 ~TREE_INT_CST_HIGH (val
)
575 + !TREE_INT_CST_LOW (val
));
577 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
580 static char format
[10]; /* "%x%09999x\0" */
582 sprintf (format
, "%%x%%0%dx", HOST_BITS_PER_INT
/ 4);
583 sprintf (pp_buffer (buffer
)->digit_buffer
, format
,
584 TREE_INT_CST_HIGH (val
),
585 TREE_INT_CST_LOW (val
));
586 pp_string (buffer
, pp_buffer (buffer
)->digit_buffer
);
590 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
594 /* Code copied from print_node. */
597 if (TREE_OVERFLOW (node
))
598 pp_string (buffer
, " overflow");
600 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
601 d
= TREE_REAL_CST (node
);
602 if (REAL_VALUE_ISINF (d
))
603 pp_string (buffer
, " Inf");
604 else if (REAL_VALUE_ISNAN (d
))
605 pp_string (buffer
, " Nan");
609 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
610 pp_string (buffer
, string
);
615 unsigned char *p
= (unsigned char *) &TREE_REAL_CST (node
);
616 pp_string (buffer
, "0x");
617 for (i
= 0; i
< sizeof TREE_REAL_CST (node
); i
++)
618 output_formatted_integer (buffer
, "%02x", *p
++);
625 pp_string (buffer
, "__complex__ (");
626 dump_generic_node (buffer
, TREE_REALPART (node
), spc
, flags
, false);
627 pp_string (buffer
, ", ");
628 dump_generic_node (buffer
, TREE_IMAGPART (node
), spc
, flags
, false);
629 pp_string (buffer
, ")");
633 pp_string (buffer
, "\"");
634 pretty_print_string (buffer
, TREE_STRING_POINTER (node
));
635 pp_string (buffer
, "\"");
641 pp_string (buffer
, "{ ");
642 for (elt
= TREE_VECTOR_CST_ELTS (node
); elt
; elt
= TREE_CHAIN (elt
))
644 dump_generic_node (buffer
, TREE_VALUE (elt
), spc
, flags
, false);
645 if (TREE_CHAIN (elt
))
646 pp_string (buffer
, ", ");
648 pp_string (buffer
, " }");
657 dump_decl_name (buffer
, node
, flags
);
661 if (DECL_NAME (node
))
662 dump_decl_name (buffer
, node
, flags
);
663 else if (LABEL_DECL_UID (node
) != -1)
664 pp_printf (buffer
, "<L" HOST_WIDE_INT_PRINT_DEC
">",
665 LABEL_DECL_UID (node
));
667 pp_printf (buffer
, "<D%u>", DECL_UID (node
));
671 if (DECL_IS_BUILTIN (node
))
673 /* Don't print the declaration of built-in types. */
676 if (DECL_NAME (node
))
677 dump_decl_name (buffer
, node
, flags
);
680 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
681 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
682 && TYPE_METHODS (TREE_TYPE (node
)))
684 /* The type is a c++ class: all structures have at least
686 pp_string (buffer
, "class ");
687 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
692 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
693 ? "union" : "struct "));
694 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
703 dump_decl_name (buffer
, node
, flags
);
707 pp_string (buffer
, "<retval>");
711 op0
= TREE_OPERAND (node
, 0);
713 if (TREE_CODE (op0
) == INDIRECT_REF
)
715 op0
= TREE_OPERAND (op0
, 0);
718 if (op_prio (op0
) < op_prio (node
))
719 pp_character (buffer
, '(');
720 dump_generic_node (buffer
, op0
, spc
, flags
, false);
721 if (op_prio (op0
) < op_prio (node
))
722 pp_character (buffer
, ')');
723 pp_string (buffer
, str
);
724 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
726 if (TREE_CODE (op0
) != VALUE_HANDLE
)
728 op0
= component_ref_field_offset (node
);
729 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
731 pp_string (buffer
, "{off: ");
732 dump_generic_node (buffer
, op0
, spc
, flags
, false);
733 pp_character (buffer
, '}');
739 pp_string (buffer
, "BIT_FIELD_REF <");
740 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
741 pp_string (buffer
, ", ");
742 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
743 pp_string (buffer
, ", ");
744 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
745 pp_string (buffer
, ">");
749 case ARRAY_RANGE_REF
:
750 op0
= TREE_OPERAND (node
, 0);
751 if (op_prio (op0
) < op_prio (node
))
752 pp_character (buffer
, '(');
753 dump_generic_node (buffer
, op0
, spc
, flags
, false);
754 if (op_prio (op0
) < op_prio (node
))
755 pp_character (buffer
, ')');
756 pp_character (buffer
, '[');
757 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
758 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
759 pp_string (buffer
, " ...");
760 pp_character (buffer
, ']');
762 op0
= array_ref_low_bound (node
);
763 op1
= array_ref_element_size (node
);
765 if (!integer_zerop (op0
)
766 || (TYPE_SIZE_UNIT (TREE_TYPE (node
))
767 && !operand_equal_p (op1
, TYPE_SIZE_UNIT (TREE_TYPE (node
)), 0)))
769 pp_string (buffer
, "{lb: ");
770 dump_generic_node (buffer
, op0
, spc
, flags
, false);
771 pp_string (buffer
, " sz: ");
772 dump_generic_node (buffer
, op1
, spc
, flags
, false);
773 pp_character (buffer
, '}');
780 bool is_struct_init
= FALSE
;
781 pp_character (buffer
, '{');
782 lnode
= CONSTRUCTOR_ELTS (node
);
783 if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
784 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
785 is_struct_init
= TRUE
;
786 while (lnode
&& lnode
!= error_mark_node
)
789 if (TREE_PURPOSE (lnode
) && is_struct_init
)
791 pp_character (buffer
, '.');
792 dump_generic_node (buffer
, TREE_PURPOSE (lnode
), spc
, flags
, false);
793 pp_string (buffer
, "=");
795 val
= TREE_VALUE (lnode
);
796 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
797 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
798 val
= TREE_OPERAND (val
, 0);
799 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
801 dump_decl_name (buffer
, val
, flags
);
805 dump_generic_node (buffer
, TREE_VALUE (lnode
), spc
, flags
, false);
807 lnode
= TREE_CHAIN (lnode
);
808 if (lnode
&& TREE_CODE (lnode
) == TREE_LIST
)
810 pp_character (buffer
, ',');
814 pp_character (buffer
, '}');
821 if (flags
& TDF_SLIM
)
823 pp_string (buffer
, "<COMPOUND_EXPR>");
827 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
828 spc
, flags
, dumping_stmts
);
830 newline_and_indent (buffer
, spc
);
833 pp_character (buffer
, ',');
837 for (tp
= &TREE_OPERAND (node
, 1);
838 TREE_CODE (*tp
) == COMPOUND_EXPR
;
839 tp
= &TREE_OPERAND (*tp
, 1))
841 dump_generic_node (buffer
, TREE_OPERAND (*tp
, 0),
842 spc
, flags
, dumping_stmts
);
844 newline_and_indent (buffer
, spc
);
847 pp_character (buffer
, ',');
852 dump_generic_node (buffer
, *tp
, spc
, flags
, dumping_stmts
);
858 tree_stmt_iterator si
;
861 if ((flags
& TDF_SLIM
) || !dumping_stmts
)
863 pp_string (buffer
, "<STATEMENT_LIST>");
867 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
870 newline_and_indent (buffer
, spc
);
873 dump_generic_node (buffer
, tsi_stmt (si
), spc
, flags
, true);
880 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
882 pp_character (buffer
, '=');
884 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
888 pp_string (buffer
, "TARGET_EXPR <");
889 dump_generic_node (buffer
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
890 pp_character (buffer
, ',');
892 dump_generic_node (buffer
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
893 pp_character (buffer
, '>');
897 print_declaration (buffer
, DECL_EXPR_DECL (node
), spc
, flags
);
902 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
904 pp_string (buffer
, "if (");
905 dump_generic_node (buffer
, COND_EXPR_COND (node
), spc
, flags
, false);
906 pp_character (buffer
, ')');
907 /* The lowered cond_exprs should always be printed in full. */
908 if (COND_EXPR_THEN (node
)
909 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
910 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
911 && COND_EXPR_ELSE (node
)
912 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
913 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
916 dump_generic_node (buffer
, COND_EXPR_THEN (node
), 0, flags
, true);
917 pp_string (buffer
, " else ");
918 dump_generic_node (buffer
, COND_EXPR_ELSE (node
), 0, flags
, true);
920 else if (!(flags
& TDF_SLIM
))
922 /* Output COND_EXPR_THEN. */
923 if (COND_EXPR_THEN (node
))
925 newline_and_indent (buffer
, spc
+2);
926 pp_character (buffer
, '{');
927 newline_and_indent (buffer
, spc
+4);
928 dump_generic_node (buffer
, COND_EXPR_THEN (node
), spc
+4,
930 newline_and_indent (buffer
, spc
+2);
931 pp_character (buffer
, '}');
934 /* Output COND_EXPR_ELSE. */
935 if (COND_EXPR_ELSE (node
))
937 newline_and_indent (buffer
, spc
);
938 pp_string (buffer
, "else");
939 newline_and_indent (buffer
, spc
+2);
940 pp_character (buffer
, '{');
941 newline_and_indent (buffer
, spc
+4);
942 dump_generic_node (buffer
, COND_EXPR_ELSE (node
), spc
+4,
944 newline_and_indent (buffer
, spc
+2);
945 pp_character (buffer
, '}');
952 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
954 pp_character (buffer
, '?');
956 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
958 pp_character (buffer
, ':');
960 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
965 pp_character (buffer
, '{');
966 if (!(flags
& TDF_SLIM
))
968 if (BIND_EXPR_VARS (node
))
972 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= TREE_CHAIN (op0
))
974 print_declaration (buffer
, op0
, spc
+2, flags
);
979 newline_and_indent (buffer
, spc
+2);
980 dump_generic_node (buffer
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
981 newline_and_indent (buffer
, spc
);
982 pp_character (buffer
, '}');
988 print_call_name (buffer
, node
);
990 /* Print parameters. */
992 pp_character (buffer
, '(');
993 op1
= TREE_OPERAND (node
, 1);
995 dump_generic_node (buffer
, op1
, spc
, flags
, false);
996 pp_character (buffer
, ')');
998 op1
= TREE_OPERAND (node
, 2);
1001 pp_string (buffer
, " [static-chain: ");
1002 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1003 pp_character (buffer
, ']');
1006 if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (node
))
1007 pp_string (buffer
, " [return slot addr]");
1008 if (CALL_EXPR_TAILCALL (node
))
1009 pp_string (buffer
, " [tail call]");
1012 case WITH_CLEANUP_EXPR
:
1016 case CLEANUP_POINT_EXPR
:
1017 pp_string (buffer
, "<<cleanup_point ");
1018 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1019 pp_string (buffer
, ">>");
1022 case PLACEHOLDER_EXPR
:
1023 pp_string (buffer
, "<PLACEHOLDER_EXPR ");
1024 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1025 pp_character (buffer
, '>');
1028 /* Binary arithmetic and logic expressions. */
1032 case TRUNC_DIV_EXPR
:
1034 case FLOOR_DIV_EXPR
:
1035 case ROUND_DIV_EXPR
:
1036 case TRUNC_MOD_EXPR
:
1038 case FLOOR_MOD_EXPR
:
1039 case ROUND_MOD_EXPR
:
1041 case EXACT_DIV_EXPR
:
1046 case VEC_LSHIFT_EXPR
:
1047 case VEC_RSHIFT_EXPR
:
1051 case TRUTH_ANDIF_EXPR
:
1052 case TRUTH_ORIF_EXPR
:
1053 case TRUTH_AND_EXPR
:
1055 case TRUTH_XOR_EXPR
:
1069 case UNORDERED_EXPR
:
1071 const char *op
= op_symbol (node
);
1072 op0
= TREE_OPERAND (node
, 0);
1073 op1
= TREE_OPERAND (node
, 1);
1075 /* When the operands are expressions with less priority,
1076 keep semantics of the tree representation. */
1077 if (op_prio (op0
) < op_prio (node
))
1079 pp_character (buffer
, '(');
1080 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1081 pp_character (buffer
, ')');
1084 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1087 pp_string (buffer
, op
);
1090 /* When the operands are expressions with less priority,
1091 keep semantics of the tree representation. */
1092 if (op_prio (op1
) < op_prio (node
))
1094 pp_character (buffer
, '(');
1095 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1096 pp_character (buffer
, ')');
1099 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1103 /* Unary arithmetic and logic expressions. */
1106 case TRUTH_NOT_EXPR
:
1108 case PREDECREMENT_EXPR
:
1109 case PREINCREMENT_EXPR
:
1110 case ALIGN_INDIRECT_REF
:
1111 case MISALIGNED_INDIRECT_REF
:
1113 if (TREE_CODE (node
) == ADDR_EXPR
1114 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
1115 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
1116 ; /* Do not output '&' for strings and function pointers. */
1118 pp_string (buffer
, op_symbol (node
));
1120 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1122 pp_character (buffer
, '(');
1123 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1124 pp_character (buffer
, ')');
1127 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1129 if (TREE_CODE (node
) == MISALIGNED_INDIRECT_REF
)
1131 pp_string (buffer
, "{misalignment: ");
1132 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1133 pp_character (buffer
, '}');
1137 case POSTDECREMENT_EXPR
:
1138 case POSTINCREMENT_EXPR
:
1139 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1141 pp_character (buffer
, '(');
1142 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1143 pp_character (buffer
, ')');
1146 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1147 pp_string (buffer
, op_symbol (node
));
1151 pp_string (buffer
, "MIN_EXPR <");
1152 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1153 pp_string (buffer
, ", ");
1154 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1155 pp_character (buffer
, '>');
1159 pp_string (buffer
, "MAX_EXPR <");
1160 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1161 pp_string (buffer
, ", ");
1162 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1163 pp_character (buffer
, '>');
1167 pp_string (buffer
, "ABS_EXPR <");
1168 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1169 pp_character (buffer
, '>');
1176 case FIX_TRUNC_EXPR
:
1178 case FIX_FLOOR_EXPR
:
1179 case FIX_ROUND_EXPR
:
1183 type
= TREE_TYPE (node
);
1184 op0
= TREE_OPERAND (node
, 0);
1185 if (type
!= TREE_TYPE (op0
))
1187 pp_character (buffer
, '(');
1188 dump_generic_node (buffer
, type
, spc
, flags
, false);
1189 pp_string (buffer
, ") ");
1191 if (op_prio (op0
) < op_prio (node
))
1192 pp_character (buffer
, '(');
1193 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1194 if (op_prio (op0
) < op_prio (node
))
1195 pp_character (buffer
, ')');
1198 case VIEW_CONVERT_EXPR
:
1199 pp_string (buffer
, "VIEW_CONVERT_EXPR<");
1200 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1201 pp_string (buffer
, ">(");
1202 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1203 pp_character (buffer
, ')');
1206 case NON_LVALUE_EXPR
:
1207 pp_string (buffer
, "NON_LVALUE_EXPR <");
1208 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1209 pp_character (buffer
, '>');
1213 pp_string (buffer
, "SAVE_EXPR <");
1214 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1215 pp_character (buffer
, '>');
1219 pp_string (buffer
, "COMPLEX_EXPR <");
1220 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1221 pp_string (buffer
, ", ");
1222 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1223 pp_string (buffer
, ">");
1227 pp_string (buffer
, "CONJ_EXPR <");
1228 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1229 pp_string (buffer
, ">");
1233 pp_string (buffer
, "REALPART_EXPR <");
1234 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1235 pp_string (buffer
, ">");
1239 pp_string (buffer
, "IMAGPART_EXPR <");
1240 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1241 pp_string (buffer
, ">");
1245 pp_string (buffer
, "VA_ARG_EXPR <");
1246 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1247 pp_string (buffer
, ">");
1250 case TRY_FINALLY_EXPR
:
1251 case TRY_CATCH_EXPR
:
1252 pp_string (buffer
, "try");
1253 newline_and_indent (buffer
, spc
+2);
1254 pp_string (buffer
, "{");
1255 newline_and_indent (buffer
, spc
+4);
1256 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
1257 newline_and_indent (buffer
, spc
+2);
1258 pp_string (buffer
, "}");
1259 newline_and_indent (buffer
, spc
);
1261 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
1262 newline_and_indent (buffer
, spc
+2);
1263 pp_string (buffer
, "{");
1264 newline_and_indent (buffer
, spc
+4);
1265 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
1266 newline_and_indent (buffer
, spc
+2);
1267 pp_string (buffer
, "}");
1272 pp_string (buffer
, "catch (");
1273 dump_generic_node (buffer
, CATCH_TYPES (node
), spc
+2, flags
, false);
1274 pp_string (buffer
, ")");
1275 newline_and_indent (buffer
, spc
+2);
1276 pp_string (buffer
, "{");
1277 newline_and_indent (buffer
, spc
+4);
1278 dump_generic_node (buffer
, CATCH_BODY (node
), spc
+4, flags
, true);
1279 newline_and_indent (buffer
, spc
+2);
1280 pp_string (buffer
, "}");
1284 case EH_FILTER_EXPR
:
1285 pp_string (buffer
, "<<<eh_filter (");
1286 dump_generic_node (buffer
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
1287 pp_string (buffer
, ")>>>");
1288 newline_and_indent (buffer
, spc
+2);
1289 pp_string (buffer
, "{");
1290 newline_and_indent (buffer
, spc
+4);
1291 dump_generic_node (buffer
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
1292 newline_and_indent (buffer
, spc
+2);
1293 pp_string (buffer
, "}");
1298 op0
= TREE_OPERAND (node
, 0);
1299 /* If this is for break or continue, don't bother printing it. */
1300 if (DECL_NAME (op0
))
1302 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
1303 if (strcmp (name
, "break") == 0
1304 || strcmp (name
, "continue") == 0)
1307 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1308 pp_character (buffer
, ':');
1309 if (DECL_NONLOCAL (op0
))
1310 pp_string (buffer
, " [non-local]");
1314 pp_string (buffer
, "<<<exception object>>>");
1318 pp_string (buffer
, "<<<filter object>>>");
1322 pp_string (buffer
, "while (1)");
1323 if (!(flags
& TDF_SLIM
))
1325 newline_and_indent (buffer
, spc
+2);
1326 pp_character (buffer
, '{');
1327 newline_and_indent (buffer
, spc
+4);
1328 dump_generic_node (buffer
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
1329 newline_and_indent (buffer
, spc
+2);
1330 pp_character (buffer
, '}');
1336 pp_string (buffer
, "return");
1337 op0
= TREE_OPERAND (node
, 0);
1341 if (TREE_CODE (op0
) == MODIFY_EXPR
)
1342 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1), spc
, flags
, false);
1344 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1349 pp_string (buffer
, "if (");
1350 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1351 pp_string (buffer
, ") break");
1355 pp_string (buffer
, "switch (");
1356 dump_generic_node (buffer
, SWITCH_COND (node
), spc
, flags
, false);
1357 pp_character (buffer
, ')');
1358 if (!(flags
& TDF_SLIM
))
1360 newline_and_indent (buffer
, spc
+2);
1361 pp_character (buffer
, '{');
1362 if (SWITCH_BODY (node
))
1364 newline_and_indent (buffer
, spc
+4);
1365 dump_generic_node (buffer
, SWITCH_BODY (node
), spc
+4, flags
, true);
1369 tree vec
= SWITCH_LABELS (node
);
1370 size_t i
, n
= TREE_VEC_LENGTH (vec
);
1371 for (i
= 0; i
< n
; ++i
)
1373 tree elt
= TREE_VEC_ELT (vec
, i
);
1374 newline_and_indent (buffer
, spc
+4);
1375 dump_generic_node (buffer
, elt
, spc
+4, flags
, false);
1376 pp_string (buffer
, " goto ");
1377 dump_generic_node (buffer
, CASE_LABEL (elt
), spc
+4, flags
, true);
1378 pp_semicolon (buffer
);
1381 newline_and_indent (buffer
, spc
+2);
1382 pp_character (buffer
, '}');
1388 op0
= GOTO_DESTINATION (node
);
1389 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
1391 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
1392 if (strcmp (name
, "break") == 0
1393 || strcmp (name
, "continue") == 0)
1395 pp_string (buffer
, name
);
1399 pp_string (buffer
, "goto ");
1400 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1404 pp_string (buffer
, "resx");
1405 /* ??? Any sensible way to present the eh region? */
1409 pp_string (buffer
, "__asm__");
1410 if (ASM_VOLATILE_P (node
))
1411 pp_string (buffer
, " __volatile__");
1412 pp_character (buffer
, '(');
1413 dump_generic_node (buffer
, ASM_STRING (node
), spc
, flags
, false);
1414 pp_character (buffer
, ':');
1415 dump_generic_node (buffer
, ASM_OUTPUTS (node
), spc
, flags
, false);
1416 pp_character (buffer
, ':');
1417 dump_generic_node (buffer
, ASM_INPUTS (node
), spc
, flags
, false);
1418 if (ASM_CLOBBERS (node
))
1420 pp_character (buffer
, ':');
1421 dump_generic_node (buffer
, ASM_CLOBBERS (node
), spc
, flags
, false);
1423 pp_string (buffer
, ")");
1426 case CASE_LABEL_EXPR
:
1427 if (CASE_LOW (node
) && CASE_HIGH (node
))
1429 pp_string (buffer
, "case ");
1430 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
1431 pp_string (buffer
, " ... ");
1432 dump_generic_node (buffer
, CASE_HIGH (node
), spc
, flags
, false);
1434 else if (CASE_LOW (node
))
1436 pp_string (buffer
, "case ");
1437 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
1440 pp_string (buffer
, "default ");
1441 pp_character (buffer
, ':');
1445 pp_string (buffer
, "OBJ_TYPE_REF(");
1446 dump_generic_node (buffer
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
1447 pp_character (buffer
, ';');
1448 dump_generic_node (buffer
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
1449 pp_character (buffer
, '-');
1450 pp_character (buffer
, '>');
1451 dump_generic_node (buffer
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
1452 pp_character (buffer
, ')');
1459 dump_generic_node (buffer
, PHI_RESULT (node
), spc
, flags
, false);
1460 pp_string (buffer
, " = PHI <");
1461 for (i
= 0; i
< PHI_NUM_ARGS (node
); i
++)
1463 dump_generic_node (buffer
, PHI_ARG_DEF (node
, i
), spc
, flags
, false);
1464 pp_string (buffer
, "(");
1465 pp_decimal_int (buffer
, PHI_ARG_EDGE (node
, i
)->src
->index
);
1466 pp_string (buffer
, ")");
1467 if (i
< PHI_NUM_ARGS (node
) - 1)
1468 pp_string (buffer
, ", ");
1470 pp_string (buffer
, ">;");
1475 dump_generic_node (buffer
, SSA_NAME_VAR (node
), spc
, flags
, false);
1476 pp_string (buffer
, "_");
1477 pp_decimal_int (buffer
, SSA_NAME_VERSION (node
));
1478 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
1479 pp_string (buffer
, "(ab)");
1482 case WITH_SIZE_EXPR
:
1483 pp_string (buffer
, "WITH_SIZE_EXPR <");
1484 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1485 pp_string (buffer
, ", ");
1486 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1487 pp_string (buffer
, ">");
1491 pp_printf (buffer
, "VH.%d", VALUE_HANDLE_ID (node
));
1495 pp_string (buffer
, "ASSERT_EXPR <");
1496 dump_generic_node (buffer
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
1497 pp_string (buffer
, ", ");
1498 dump_generic_node (buffer
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
1499 pp_string (buffer
, ">");
1503 pp_string (buffer
, "scev_known");
1506 case SCEV_NOT_KNOWN
:
1507 pp_string (buffer
, "scev_not_known");
1510 case POLYNOMIAL_CHREC
:
1511 pp_string (buffer
, "{");
1512 dump_generic_node (buffer
, CHREC_LEFT (node
), spc
, flags
, false);
1513 pp_string (buffer
, ", +, ");
1514 dump_generic_node (buffer
, CHREC_RIGHT (node
), spc
, flags
, false);
1515 pp_string (buffer
, "}_");
1516 dump_generic_node (buffer
, CHREC_VAR (node
), spc
, flags
, false);
1520 case REALIGN_LOAD_EXPR
:
1521 pp_string (buffer
, "REALIGN_LOAD <");
1522 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1523 pp_string (buffer
, ", ");
1524 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1525 pp_string (buffer
, ", ");
1526 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1527 pp_string (buffer
, ">");
1531 pp_string (buffer
, " VEC_COND_EXPR < ");
1532 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1533 pp_string (buffer
, " , ");
1534 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1535 pp_string (buffer
, " , ");
1536 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1537 pp_string (buffer
, " > ");
1540 case REDUC_MAX_EXPR
:
1541 pp_string (buffer
, " REDUC_MAX_EXPR < ");
1542 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1543 pp_string (buffer
, " > ");
1546 case REDUC_MIN_EXPR
:
1547 pp_string (buffer
, " REDUC_MIN_EXPR < ");
1548 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1549 pp_string (buffer
, " > ");
1552 case REDUC_PLUS_EXPR
:
1553 pp_string (buffer
, " REDUC_PLUS_EXPR < ");
1554 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1555 pp_string (buffer
, " > ");
1562 if (is_stmt
&& is_expr
)
1563 pp_semicolon (buffer
);
1564 pp_write_text_to_stream (buffer
);
1569 /* Print the declaration of a variable. */
1572 print_declaration (pretty_printer
*buffer
, tree t
, int spc
, int flags
)
1576 if (TREE_CODE (t
) == TYPE_DECL
)
1577 pp_string (buffer
, "typedef ");
1579 if (DECL_REGISTER (t
))
1580 pp_string (buffer
, "register ");
1582 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
1583 pp_string (buffer
, "extern ");
1584 else if (TREE_STATIC (t
))
1585 pp_string (buffer
, "static ");
1587 /* Print the type and name. */
1588 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
1592 /* Print array's type. */
1593 tmp
= TREE_TYPE (t
);
1594 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
1595 tmp
= TREE_TYPE (tmp
);
1596 dump_generic_node (buffer
, TREE_TYPE (tmp
), spc
, flags
, false);
1598 /* Print variable's name. */
1600 dump_generic_node (buffer
, t
, spc
, flags
, false);
1602 /* Print the dimensions. */
1603 tmp
= TREE_TYPE (t
);
1604 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
1606 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
1607 tmp
= TREE_TYPE (tmp
);
1610 else if (TREE_CODE (t
) == FUNCTION_DECL
)
1612 dump_generic_node (buffer
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
1614 dump_decl_name (buffer
, t
, flags
);
1615 dump_function_declaration (buffer
, TREE_TYPE (t
), spc
, flags
);
1619 /* Print type declaration. */
1620 dump_generic_node (buffer
, TREE_TYPE (t
), spc
, flags
, false);
1622 /* Print variable's name. */
1624 dump_generic_node (buffer
, t
, spc
, flags
, false);
1627 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
1629 pp_string (buffer
, " __asm__ ");
1630 pp_character (buffer
, '(');
1631 dump_generic_node (buffer
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
1632 pp_character (buffer
, ')');
1635 /* The initial value of a function serves to determine wether the function
1636 is declared or defined. So the following does not apply to function
1638 if (TREE_CODE (t
) != FUNCTION_DECL
)
1640 /* Print the initial value. */
1641 if (DECL_INITIAL (t
))
1644 pp_character (buffer
, '=');
1646 dump_generic_node (buffer
, DECL_INITIAL (t
), spc
, flags
, false);
1650 pp_character (buffer
, ';');
1654 /* Prints a structure: name, fields, and methods.
1655 FIXME: Still incomplete. */
1658 print_struct_decl (pretty_printer
*buffer
, tree node
, int spc
, int flags
)
1660 /* Print the name of the structure. */
1661 if (TYPE_NAME (node
))
1664 if (TREE_CODE (node
) == RECORD_TYPE
)
1665 pp_string (buffer
, "struct ");
1666 else if ((TREE_CODE (node
) == UNION_TYPE
1667 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
1668 pp_string (buffer
, "union ");
1670 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, 0, false);
1673 /* Print the contents of the structure. */
1674 pp_newline (buffer
);
1676 pp_character (buffer
, '{');
1677 pp_newline (buffer
);
1679 /* Print the fields of the structure. */
1682 tmp
= TYPE_FIELDS (node
);
1685 /* Avoid to print recursively the structure. */
1686 /* FIXME : Not implemented correctly...,
1687 what about the case when we have a cycle in the contain graph? ...
1688 Maybe this could be solved by looking at the scope in which the
1689 structure was declared. */
1690 if (TREE_TYPE (tmp
) != node
1691 || (TREE_CODE (TREE_TYPE (tmp
)) == POINTER_TYPE
1692 && TREE_TYPE (TREE_TYPE (tmp
)) != node
))
1694 print_declaration (buffer
, tmp
, spc
+2, flags
);
1695 pp_newline (buffer
);
1697 tmp
= TREE_CHAIN (tmp
);
1701 pp_character (buffer
, '}');
1704 /* Return the priority of the operator OP.
1706 From lowest to highest precedence with either left-to-right (L-R)
1707 or right-to-left (R-L) associativity]:
1710 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
1722 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
1723 15 [L-R] fn() [] -> .
1725 unary +, - and * have higher precedence than the corresponding binary
1734 switch (TREE_CODE (op
))
1749 case TRUTH_ORIF_EXPR
:
1752 case TRUTH_AND_EXPR
:
1753 case TRUTH_ANDIF_EXPR
:
1760 case TRUTH_XOR_EXPR
:
1777 case UNORDERED_EXPR
:
1795 case TRUNC_DIV_EXPR
:
1797 case FLOOR_DIV_EXPR
:
1798 case ROUND_DIV_EXPR
:
1800 case EXACT_DIV_EXPR
:
1801 case TRUNC_MOD_EXPR
:
1803 case FLOOR_MOD_EXPR
:
1804 case ROUND_MOD_EXPR
:
1807 case TRUTH_NOT_EXPR
:
1809 case POSTINCREMENT_EXPR
:
1810 case POSTDECREMENT_EXPR
:
1811 case PREINCREMENT_EXPR
:
1812 case PREDECREMENT_EXPR
:
1814 case ALIGN_INDIRECT_REF
:
1815 case MISALIGNED_INDIRECT_REF
:
1821 case FIX_TRUNC_EXPR
:
1823 case FIX_FLOOR_EXPR
:
1824 case FIX_ROUND_EXPR
:
1830 case ARRAY_RANGE_REF
:
1834 /* Special expressions. */
1840 case REDUC_MAX_EXPR
:
1841 case REDUC_MIN_EXPR
:
1842 case REDUC_PLUS_EXPR
:
1843 case VEC_LSHIFT_EXPR
:
1844 case VEC_RSHIFT_EXPR
:
1848 case NON_LVALUE_EXPR
:
1849 return op_prio (TREE_OPERAND (op
, 0));
1852 /* Return an arbitrarily high precedence to avoid surrounding single
1853 VAR_DECLs in ()s. */
1859 /* Return the symbol associated with operator OP. */
1866 switch (TREE_CODE (op
))
1872 case TRUTH_ORIF_EXPR
:
1875 case TRUTH_AND_EXPR
:
1876 case TRUTH_ANDIF_EXPR
:
1882 case TRUTH_XOR_EXPR
:
1892 case UNORDERED_EXPR
:
1932 case VEC_LSHIFT_EXPR
:
1935 case VEC_RSHIFT_EXPR
:
1941 case REDUC_PLUS_EXPR
:
1951 case TRUTH_NOT_EXPR
:
1958 case ALIGN_INDIRECT_REF
:
1961 case MISALIGNED_INDIRECT_REF
:
1964 case TRUNC_DIV_EXPR
:
1971 case FLOOR_DIV_EXPR
:
1974 case ROUND_DIV_EXPR
:
1977 case EXACT_DIV_EXPR
:
1980 case TRUNC_MOD_EXPR
:
1986 case FLOOR_MOD_EXPR
:
1989 case ROUND_MOD_EXPR
:
1992 case PREDECREMENT_EXPR
:
1995 case PREINCREMENT_EXPR
:
1998 case POSTDECREMENT_EXPR
:
2001 case POSTINCREMENT_EXPR
:
2005 return "<<< ??? >>>";
2009 /* Prints the name of a CALL_EXPR. */
2012 print_call_name (pretty_printer
*buffer
, tree node
)
2016 gcc_assert (TREE_CODE (node
) == CALL_EXPR
);
2018 op0
= TREE_OPERAND (node
, 0);
2020 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
2021 op0
= TREE_OPERAND (op0
, 0);
2023 switch (TREE_CODE (op0
))
2027 dump_function_name (buffer
, op0
);
2033 dump_generic_node (buffer
, TREE_OPERAND (op0
, 0), 0, 0, false);
2037 pp_string (buffer
, "(");
2038 dump_generic_node (buffer
, TREE_OPERAND (op0
, 0), 0, 0, false);
2039 pp_string (buffer
, ") ? ");
2040 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1), 0, 0, false);
2041 pp_string (buffer
, " : ");
2042 dump_generic_node (buffer
, TREE_OPERAND (op0
, 2), 0, 0, false);
2046 /* The function is a pointer contained in a structure. */
2047 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == INDIRECT_REF
||
2048 TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
2049 dump_function_name (buffer
, TREE_OPERAND (op0
, 1));
2051 dump_generic_node (buffer
, TREE_OPERAND (op0
, 0), 0, 0, false);
2053 We can have several levels of structures and a function
2054 pointer inside. This is not implemented yet... */
2059 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
2060 dump_function_name (buffer
, TREE_OPERAND (op0
, 0));
2062 dump_generic_node (buffer
, op0
, 0, 0, false);
2067 dump_generic_node (buffer
, op0
, 0, 0, false);
2075 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2078 pretty_print_string (pretty_printer
*buffer
, const char *str
)
2088 pp_string (buffer
, "\\b");
2092 pp_string (buffer
, "\\f");
2096 pp_string (buffer
, "\\n");
2100 pp_string (buffer
, "\\r");
2104 pp_string (buffer
, "\\t");
2108 pp_string (buffer
, "\\v");
2112 pp_string (buffer
, "\\\\");
2116 pp_string (buffer
, "\\\"");
2120 pp_string (buffer
, "\\'");
2124 pp_string (buffer
, "\\0");
2128 pp_string (buffer
, "\\1");
2132 pp_string (buffer
, "\\2");
2136 pp_string (buffer
, "\\3");
2140 pp_string (buffer
, "\\4");
2144 pp_string (buffer
, "\\5");
2148 pp_string (buffer
, "\\6");
2152 pp_string (buffer
, "\\7");
2156 pp_character (buffer
, str
[0]);
2164 maybe_init_pretty_print (FILE *file
)
2168 pp_construct (&buffer
, /* prefix */NULL
, /* line-width */0);
2169 pp_needs_newline (&buffer
) = true;
2173 buffer
.buffer
->stream
= file
;
2177 newline_and_indent (pretty_printer
*buffer
, int spc
)
2179 pp_newline (buffer
);
2184 dump_vops (pretty_printer
*buffer
, tree stmt
, int spc
, int flags
)
2187 use_operand_p use_p
;
2188 def_operand_p def_p
;
2189 use_operand_p kill_p
;
2192 if (!ssa_operands_active ())
2195 FOR_EACH_SSA_MAYDEF_OPERAND (def_p
, use_p
, stmt
, iter
)
2197 pp_string (buffer
, "# ");
2198 dump_generic_node (buffer
, DEF_FROM_PTR (def_p
),
2199 spc
+ 2, flags
, false);
2200 pp_string (buffer
, " = V_MAY_DEF <");
2201 dump_generic_node (buffer
, USE_FROM_PTR (use_p
),
2202 spc
+ 2, flags
, false);
2203 pp_string (buffer
, ">;");
2204 newline_and_indent (buffer
, spc
);
2207 FOR_EACH_SSA_MUSTDEF_OPERAND (def_p
, kill_p
, stmt
, iter
)
2209 pp_string (buffer
, "# ");
2210 dump_generic_node (buffer
, DEF_FROM_PTR (def_p
),
2211 spc
+ 2, flags
, false);
2212 pp_string (buffer
, " = V_MUST_DEF <");
2213 dump_generic_node (buffer
, USE_FROM_PTR (kill_p
),
2214 spc
+ 2, flags
, false);
2215 pp_string (buffer
, ">;");
2216 newline_and_indent (buffer
, spc
);
2219 FOR_EACH_SSA_TREE_OPERAND (use
, stmt
, iter
, SSA_OP_VUSE
)
2221 pp_string (buffer
, "# VUSE <");
2222 dump_generic_node (buffer
, use
, spc
+ 2, flags
, false);
2223 pp_string (buffer
, ">;");
2224 newline_and_indent (buffer
, spc
);
2228 /* Dumps basic block BB to FILE with details described by FLAGS and
2229 indented by INDENT spaces. */
2232 dump_generic_bb (FILE *file
, basic_block bb
, int indent
, int flags
)
2234 maybe_init_pretty_print (file
);
2235 dumping_stmts
= true;
2236 dump_generic_bb_buff (&buffer
, bb
, indent
, flags
);
2240 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2241 spaces and details described by flags. */
2244 dump_bb_header (pretty_printer
*buffer
, basic_block bb
, int indent
, int flags
)
2250 if (flags
& TDF_BLOCKS
)
2253 pp_string (buffer
, "# BLOCK ");
2254 pp_decimal_int (buffer
, bb
->index
);
2256 if (flags
& TDF_LINENO
)
2258 block_stmt_iterator bsi
;
2260 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
2261 if (get_lineno (bsi_stmt (bsi
)) != -1)
2263 pp_string (buffer
, ", starting at line ");
2264 pp_decimal_int (buffer
, get_lineno (bsi_stmt (bsi
)));
2268 newline_and_indent (buffer
, indent
);
2270 pp_string (buffer
, "# PRED:");
2271 pp_write_text_to_stream (buffer
);
2272 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
2273 if (flags
& TDF_SLIM
)
2275 pp_string (buffer
, " ");
2276 if (e
->src
== ENTRY_BLOCK_PTR
)
2277 pp_string (buffer
, "ENTRY");
2279 pp_decimal_int (buffer
, e
->src
->index
);
2282 dump_edge_info (buffer
->buffer
->stream
, e
, 0);
2283 pp_newline (buffer
);
2287 stmt
= first_stmt (bb
);
2288 if (!stmt
|| TREE_CODE (stmt
) != LABEL_EXPR
)
2290 INDENT (indent
- 2);
2291 pp_string (buffer
, "<bb ");
2292 pp_decimal_int (buffer
, bb
->index
);
2293 pp_string (buffer
, ">:");
2294 pp_newline (buffer
);
2297 pp_write_text_to_stream (buffer
);
2298 check_bb_profile (bb
, buffer
->buffer
->stream
);
2301 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2305 dump_bb_end (pretty_printer
*buffer
, basic_block bb
, int indent
, int flags
)
2311 pp_string (buffer
, "# SUCC:");
2312 pp_write_text_to_stream (buffer
);
2313 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2314 if (flags
& TDF_SLIM
)
2316 pp_string (buffer
, " ");
2317 if (e
->dest
== EXIT_BLOCK_PTR
)
2318 pp_string (buffer
, "EXIT");
2320 pp_decimal_int (buffer
, e
->dest
->index
);
2323 dump_edge_info (buffer
->buffer
->stream
, e
, 1);
2324 pp_newline (buffer
);
2327 /* Dumps phi nodes of basic block BB to buffer BUFFER with details described by
2328 FLAGS indented by INDENT spaces. */
2331 dump_phi_nodes (pretty_printer
*buffer
, basic_block bb
, int indent
, int flags
)
2333 tree phi
= phi_nodes (bb
);
2337 for (; phi
; phi
= PHI_CHAIN (phi
))
2339 if (is_gimple_reg (PHI_RESULT (phi
)) || (flags
& TDF_VOPS
))
2342 pp_string (buffer
, "# ");
2343 dump_generic_node (buffer
, phi
, indent
, flags
, false);
2344 pp_newline (buffer
);
2349 /* Dump jump to basic block BB that is represented implicitly in the cfg
2353 pp_cfg_jump (pretty_printer
*buffer
, basic_block bb
)
2357 stmt
= first_stmt (bb
);
2359 pp_string (buffer
, "goto <bb ");
2360 pp_decimal_int (buffer
, bb
->index
);
2361 pp_string (buffer
, ">");
2362 if (stmt
&& TREE_CODE (stmt
) == LABEL_EXPR
)
2364 pp_string (buffer
, " (");
2365 dump_generic_node (buffer
, LABEL_EXPR_LABEL (stmt
), 0, 0, false);
2366 pp_string (buffer
, ")");
2368 pp_semicolon (buffer
);
2371 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
2372 by INDENT spaces, with details given by FLAGS. */
2375 dump_implicit_edges (pretty_printer
*buffer
, basic_block bb
, int indent
,
2381 /* If there is a fallthru edge, we may need to add an artificial goto to the
2383 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2384 if (e
->flags
& EDGE_FALLTHRU
)
2386 if (e
&& e
->dest
!= bb
->next_bb
)
2390 if ((flags
& TDF_LINENO
)
2391 #ifdef USE_MAPPED_LOCATION
2392 && e
->goto_locus
!= UNKNOWN_LOCATION
2398 expanded_location goto_xloc
;
2399 #ifdef USE_MAPPED_LOCATION
2400 goto_xloc
= expand_location (e
->goto_locus
);
2402 goto_xloc
= *e
->goto_locus
;
2404 pp_character (buffer
, '[');
2407 pp_string (buffer
, goto_xloc
.file
);
2408 pp_string (buffer
, " : ");
2410 pp_decimal_int (buffer
, goto_xloc
.line
);
2411 pp_string (buffer
, "] ");
2414 pp_cfg_jump (buffer
, e
->dest
);
2415 pp_newline (buffer
);
2419 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2420 indented by INDENT spaces. */
2423 dump_generic_bb_buff (pretty_printer
*buffer
, basic_block bb
,
2424 int indent
, int flags
)
2426 block_stmt_iterator bsi
;
2428 int label_indent
= indent
- 2;
2430 if (label_indent
< 0)
2433 dump_bb_header (buffer
, bb
, indent
, flags
);
2435 dump_phi_nodes (buffer
, bb
, indent
, flags
);
2437 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
2441 stmt
= bsi_stmt (bsi
);
2443 curr_indent
= TREE_CODE (stmt
) == LABEL_EXPR
? label_indent
: indent
;
2445 INDENT (curr_indent
);
2446 dump_generic_node (buffer
, stmt
, curr_indent
, flags
, true);
2447 pp_newline (buffer
);
2450 dump_implicit_edges (buffer
, bb
, indent
, flags
);
2452 if (flags
& TDF_BLOCKS
)
2453 dump_bb_end (buffer
, bb
, indent
, flags
);