1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001, 2002, 2003, 2004 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"
28 #include "diagnostic.h"
31 #include "tree-flow.h"
32 #include "langhooks.h"
33 #include "tree-iterator.h"
34 #include "tree-chrec.h"
36 /* Local functions, macros and variables. */
37 static int op_prio (tree);
38 static const char *op_symbol (tree);
39 static void pretty_print_string (pretty_printer *, const char*);
40 static void print_call_name (pretty_printer *, tree);
41 static void newline_and_indent (pretty_printer *, int);
42 static void maybe_init_pretty_print (FILE *);
43 static void print_declaration (pretty_printer *, tree, int, int);
44 static void print_struct_decl (pretty_printer *, tree, int, int);
45 static void do_niy (pretty_printer *, tree);
46 static void dump_vops (pretty_printer *, tree, int, int);
47 static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
49 #define INDENT(SPACE) do { \
50 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
52 #define NIY do_niy(buffer,node)
54 #define PRINT_FUNCTION_NAME(NODE) pp_printf \
55 (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \
56 lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
57 lang_hooks.decl_printable_name (NODE, 1))
59 static pretty_printer buffer;
60 static int initialized = 0;
61 static bool dumping_stmts;
63 /* Try to print something for an unknown tree code. */
66 do_niy (pretty_printer *buffer, tree node)
70 pp_string (buffer, "<<< Unknown tree: ");
71 pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
75 len = first_rtl_op (TREE_CODE (node));
76 for (i = 0; i < len; ++i)
78 newline_and_indent (buffer, 2);
79 dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);
83 pp_string (buffer, " >>>\n");
87 debug_generic_expr (tree t)
89 print_generic_expr (stderr, t, TDF_VOPS|TDF_UID);
90 fprintf (stderr, "\n");
94 debug_generic_stmt (tree t)
96 print_generic_stmt (stderr, t, TDF_VOPS|TDF_UID);
97 fprintf (stderr, "\n");
100 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
102 print_generic_decl (FILE *file, tree decl, int flags)
104 maybe_init_pretty_print (file);
105 dumping_stmts = true;
106 print_declaration (&buffer, decl, 2, flags);
107 pp_write_text_to_stream (&buffer);
110 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
111 to show in the dump. See TDF_* in tree.h. */
114 print_generic_stmt (FILE *file, tree t, int flags)
116 maybe_init_pretty_print (file);
117 dumping_stmts = true;
118 dump_generic_node (&buffer, t, 0, flags, true);
122 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
123 to show in the dump. See TDF_* in tree.h. The output is indented by
127 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
131 maybe_init_pretty_print (file);
132 dumping_stmts = true;
134 for (i = 0; i < indent; i++)
136 dump_generic_node (&buffer, t, indent, flags, true);
140 /* Print a single expression T on file FILE. FLAGS specifies details to show
141 in the dump. See TDF_* in tree.h. */
144 print_generic_expr (FILE *file, tree t, int flags)
146 maybe_init_pretty_print (file);
147 dumping_stmts = false;
148 dump_generic_node (&buffer, t, 0, flags, false);
151 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
155 dump_decl_name (pretty_printer *buffer, tree node, int flags)
157 if (DECL_NAME (node))
158 pp_tree_identifier (buffer, DECL_NAME (node));
160 if ((flags & TDF_UID)
161 || DECL_NAME (node) == NULL_TREE)
163 if (TREE_CODE (node) == LABEL_DECL
164 && LABEL_DECL_UID (node) != -1)
165 pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
166 LABEL_DECL_UID (node));
169 char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
170 pp_printf (buffer, "%c.%u", c, DECL_UID (node));
175 /* Like the above, but used for pretty printing function calls. */
178 dump_function_name (pretty_printer *buffer, tree node)
180 if (DECL_NAME (node))
181 PRINT_FUNCTION_NAME (node);
183 dump_decl_name (buffer, node, 0);
186 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
187 FLAGS are as in dump_generic_node. */
190 dump_function_declaration (pretty_printer *buffer, tree node,
193 bool wrote_arg = false;
197 pp_character (buffer, '(');
199 /* Print the argument types. The last element in the list is a VOID_TYPE.
200 The following avoids printing the last element. */
201 arg = TYPE_ARG_TYPES (node);
202 while (arg && TREE_CHAIN (arg) && arg != error_mark_node)
205 dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
206 arg = TREE_CHAIN (arg);
207 if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)
209 pp_character (buffer, ',');
215 pp_string (buffer, "void");
217 pp_character (buffer, ')');
220 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
221 FLAGS specifies details to show in the dump (see TDF_* in tree.h). If
222 IS_STMT is true, the object printed is considered to be a statement
223 and it is terminated by ';' if appropriate. */
226 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
234 if (node == NULL_TREE)
237 is_expr = EXPR_P (node);
239 if (TREE_CODE (node) != ERROR_MARK
240 && is_gimple_stmt (node)
241 && (flags & TDF_VOPS)
243 dump_vops (buffer, node, spc, flags);
246 && (flags & TDF_LINENO)
247 && EXPR_HAS_LOCATION (node))
249 expanded_location xloc = expand_location (EXPR_LOCATION (node));
250 pp_character (buffer, '[');
253 pp_string (buffer, xloc.file);
254 pp_string (buffer, " : ");
256 pp_decimal_int (buffer, xloc.line);
257 pp_string (buffer, "] ");
260 switch (TREE_CODE (node))
263 pp_string (buffer, "<<< error >>>");
266 case IDENTIFIER_NODE:
267 pp_tree_identifier (buffer, node);
271 while (node && node != error_mark_node)
273 if (TREE_PURPOSE (node))
275 dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
278 dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
279 node = TREE_CHAIN (node);
280 if (node && TREE_CODE (node) == TREE_LIST)
282 pp_character (buffer, ',');
289 dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
305 unsigned int quals = TYPE_QUALS (node);
306 enum tree_code_class class;
308 if (quals & TYPE_QUAL_CONST)
309 pp_string (buffer, "const ");
310 else if (quals & TYPE_QUAL_VOLATILE)
311 pp_string (buffer, "volatile ");
312 else if (quals & TYPE_QUAL_RESTRICT)
313 pp_string (buffer, "restrict ");
315 class = TREE_CODE_CLASS (TREE_CODE (node));
317 if (class == tcc_declaration)
319 if (DECL_NAME (node))
320 dump_decl_name (buffer, node, flags);
322 pp_string (buffer, "<unnamed type decl>");
324 else if (class == tcc_type)
326 if (TYPE_NAME (node))
328 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
329 pp_tree_identifier (buffer, TYPE_NAME (node));
330 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
331 && DECL_NAME (TYPE_NAME (node)))
332 dump_decl_name (buffer, TYPE_NAME (node), flags);
334 pp_string (buffer, "<unnamed type>");
337 pp_string (buffer, "<unnamed type>");
344 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
346 if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
348 tree fnode = TREE_TYPE (node);
350 dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
352 pp_character (buffer, '(');
353 pp_string (buffer, str);
354 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
355 dump_decl_name (buffer, TYPE_NAME (node), flags);
357 pp_printf (buffer, "<T%x>", TYPE_UID (node));
359 pp_character (buffer, ')');
360 dump_function_declaration (buffer, fnode, spc, flags);
364 unsigned int quals = TYPE_QUALS (node);
366 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
368 pp_string (buffer, str);
370 if (quals & TYPE_QUAL_CONST)
371 pp_string (buffer, " const");
372 else if (quals & TYPE_QUAL_VOLATILE)
373 pp_string (buffer, "volatile");
374 else if (quals & TYPE_QUAL_RESTRICT)
375 pp_string (buffer, " restrict");
384 dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
385 pp_string (buffer, "::");
396 /* Print the innermost component type. */
397 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
398 tmp = TREE_TYPE (tmp))
400 dump_generic_node (buffer, tmp, spc, flags, false);
402 /* Print the dimensions. */
403 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE;
404 tmp = TREE_TYPE (tmp))
406 tree domain = TYPE_DOMAIN (tmp);
408 pp_character (buffer, '[');
411 if (TYPE_MIN_VALUE (domain)
412 && !integer_zerop (TYPE_MIN_VALUE (domain)))
414 dump_generic_node (buffer, TYPE_MIN_VALUE (domain),
416 pp_string (buffer, " .. ");
419 if (TYPE_MAX_VALUE (domain))
420 dump_generic_node (buffer, TYPE_MAX_VALUE (domain),
424 pp_string (buffer, "<unknown>");
426 pp_character (buffer, ']');
437 case QUAL_UNION_TYPE:
438 /* Print the name of the structure. */
439 if (TREE_CODE (node) == RECORD_TYPE)
440 pp_string (buffer, "struct ");
441 else if (TREE_CODE (node) == UNION_TYPE)
442 pp_string (buffer, "union ");
444 if (TYPE_NAME (node))
445 dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
447 print_struct_decl (buffer, node, spc, flags);
455 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
457 /* In the case of a pointer, one may want to divide by the
458 size of the pointed-to type. Unfortunately, this not
459 straightforward. The C front-end maps expressions
464 in such a way that the two INTEGER_CST nodes for "5" have
465 different values but identical types. In the latter
466 case, the 5 is multiplied by sizeof (int) in c-common.c
467 (pointer_int_sum) to convert it to a byte address, and
468 yet the type of the node is left unchanged. Argh. What
469 is consistent though is that the number value corresponds
470 to bytes (UNITS) offset.
472 NB: Neither of the following divisors can be trivially
473 used to recover the original literal:
475 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
476 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
477 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
478 pp_string (buffer, "B"); /* pseudo-unit */
480 else if (! host_integerp (node, 0))
484 if (tree_int_cst_sgn (val) < 0)
486 pp_character (buffer, '-');
487 val = build_int_cst_wide (NULL_TREE,
488 -TREE_INT_CST_LOW (val),
489 ~TREE_INT_CST_HIGH (val)
490 + !TREE_INT_CST_LOW (val));
492 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
495 static char format[10]; /* "%x%09999x\0" */
497 sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
498 sprintf (pp_buffer (buffer)->digit_buffer, format,
499 TREE_INT_CST_HIGH (val),
500 TREE_INT_CST_LOW (val));
501 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
505 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
509 /* Code copied from print_node. */
512 if (TREE_OVERFLOW (node))
513 pp_string (buffer, " overflow");
515 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
516 d = TREE_REAL_CST (node);
517 if (REAL_VALUE_ISINF (d))
518 pp_string (buffer, " Inf");
519 else if (REAL_VALUE_ISNAN (d))
520 pp_string (buffer, " Nan");
524 real_to_decimal (string, &d, sizeof (string), 0, 1);
525 pp_string (buffer, string);
530 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
531 pp_string (buffer, "0x");
532 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
533 output_formatted_integer (buffer, "%02x", *p++);
540 pp_string (buffer, "__complex__ (");
541 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
542 pp_string (buffer, ", ");
543 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
544 pp_string (buffer, ")");
548 pp_string (buffer, "\"");
549 pretty_print_string (buffer, TREE_STRING_POINTER (node));
550 pp_string (buffer, "\"");
556 pp_string (buffer, "{ ");
557 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
559 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
560 if (TREE_CHAIN (elt))
561 pp_string (buffer, ", ");
563 pp_string (buffer, " }");
572 dump_decl_name (buffer, node, flags);
576 if (DECL_NAME (node))
577 dump_decl_name (buffer, node, flags);
578 else if (LABEL_DECL_UID (node) != -1)
579 pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
580 LABEL_DECL_UID (node));
582 pp_printf (buffer, "<D%u>", DECL_UID (node));
586 if (DECL_IS_BUILTIN (node))
588 /* Don't print the declaration of built-in types. */
591 if (DECL_NAME (node))
592 dump_decl_name (buffer, node, flags);
595 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
596 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
597 && TYPE_METHODS (TREE_TYPE (node)))
599 /* The type is a c++ class: all structures have at least
601 pp_string (buffer, "class ");
602 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
607 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
608 ? "union" : "struct "));
609 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
618 dump_decl_name (buffer, node, flags);
622 pp_string (buffer, "<retval>");
626 op0 = TREE_OPERAND (node, 0);
628 if (TREE_CODE (op0) == INDIRECT_REF)
630 op0 = TREE_OPERAND (op0, 0);
633 if (op_prio (op0) < op_prio (node))
634 pp_character (buffer, '(');
635 dump_generic_node (buffer, op0, spc, flags, false);
636 if (op_prio (op0) < op_prio (node))
637 pp_character (buffer, ')');
638 pp_string (buffer, str);
639 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
641 if (TREE_CODE (op0) != VALUE_HANDLE)
643 op0 = component_ref_field_offset (node);
644 if (op0 && TREE_CODE (op0) != INTEGER_CST)
646 pp_string (buffer, "{off: ");
647 dump_generic_node (buffer, op0, spc, flags, false);
648 pp_character (buffer, '}');
654 pp_string (buffer, "BIT_FIELD_REF <");
655 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
656 pp_string (buffer, ", ");
657 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
658 pp_string (buffer, ", ");
659 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
660 pp_string (buffer, ">");
664 case ARRAY_RANGE_REF:
665 op0 = TREE_OPERAND (node, 0);
666 if (op_prio (op0) < op_prio (node))
667 pp_character (buffer, '(');
668 dump_generic_node (buffer, op0, spc, flags, false);
669 if (op_prio (op0) < op_prio (node))
670 pp_character (buffer, ')');
671 pp_character (buffer, '[');
672 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
673 if (TREE_CODE (node) == ARRAY_RANGE_REF)
674 pp_string (buffer, " ...");
675 pp_character (buffer, ']');
677 op0 = array_ref_low_bound (node);
678 op1 = array_ref_element_size (node);
680 if (!integer_zerop (op0)
681 || (TYPE_SIZE_UNIT (TREE_TYPE (node))
682 && !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0)))
684 pp_string (buffer, "{lb: ");
685 dump_generic_node (buffer, op0, spc, flags, false);
686 pp_string (buffer, " sz: ");
687 dump_generic_node (buffer, op1, spc, flags, false);
688 pp_character (buffer, '}');
695 bool is_struct_init = FALSE;
696 pp_character (buffer, '{');
697 lnode = CONSTRUCTOR_ELTS (node);
698 if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
699 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
700 is_struct_init = TRUE;
701 while (lnode && lnode != error_mark_node)
704 if (TREE_PURPOSE (lnode) && is_struct_init)
706 pp_character (buffer, '.');
707 dump_generic_node (buffer, TREE_PURPOSE (lnode), spc, flags, false);
708 pp_string (buffer, "=");
710 val = TREE_VALUE (lnode);
711 if (val && TREE_CODE (val) == ADDR_EXPR)
712 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
713 val = TREE_OPERAND (val, 0);
714 if (val && TREE_CODE (val) == FUNCTION_DECL)
716 dump_decl_name (buffer, val, flags);
720 dump_generic_node (buffer, TREE_VALUE (lnode), spc, flags, false);
722 lnode = TREE_CHAIN (lnode);
723 if (lnode && TREE_CODE (lnode) == TREE_LIST)
725 pp_character (buffer, ',');
729 pp_character (buffer, '}');
736 if (flags & TDF_SLIM)
738 pp_string (buffer, "<COMPOUND_EXPR>");
742 dump_generic_node (buffer, TREE_OPERAND (node, 0),
743 spc, flags, dumping_stmts);
745 newline_and_indent (buffer, spc);
748 pp_character (buffer, ',');
752 for (tp = &TREE_OPERAND (node, 1);
753 TREE_CODE (*tp) == COMPOUND_EXPR;
754 tp = &TREE_OPERAND (*tp, 1))
756 dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
757 spc, flags, dumping_stmts);
759 newline_and_indent (buffer, spc);
762 pp_character (buffer, ',');
767 dump_generic_node (buffer, *tp, spc, flags, dumping_stmts);
773 tree_stmt_iterator si;
776 if ((flags & TDF_SLIM) || !dumping_stmts)
778 pp_string (buffer, "<STATEMENT_LIST>");
782 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
785 newline_and_indent (buffer, spc);
788 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
795 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
797 pp_character (buffer, '=');
799 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
803 pp_string (buffer, "TARGET_EXPR <");
804 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
805 pp_character (buffer, ',');
807 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
808 pp_character (buffer, '>');
812 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
817 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
819 pp_string (buffer, "if (");
820 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
821 pp_character (buffer, ')');
822 /* The lowered cond_exprs should always be printed in full. */
823 if (COND_EXPR_THEN (node)
824 && TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR
825 && COND_EXPR_ELSE (node)
826 && TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR)
829 dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);
830 pp_string (buffer, " else ");
831 dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true);
833 else if (!(flags & TDF_SLIM))
835 /* Output COND_EXPR_THEN. */
836 if (COND_EXPR_THEN (node))
838 newline_and_indent (buffer, spc+2);
839 pp_character (buffer, '{');
840 newline_and_indent (buffer, spc+4);
841 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
843 newline_and_indent (buffer, spc+2);
844 pp_character (buffer, '}');
847 /* Output COND_EXPR_ELSE. */
848 if (COND_EXPR_ELSE (node))
850 newline_and_indent (buffer, spc);
851 pp_string (buffer, "else");
852 newline_and_indent (buffer, spc+2);
853 pp_character (buffer, '{');
854 newline_and_indent (buffer, spc+4);
855 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
857 newline_and_indent (buffer, spc+2);
858 pp_character (buffer, '}');
865 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
867 pp_character (buffer, '?');
869 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
871 pp_character (buffer, ':');
873 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
878 pp_character (buffer, '{');
879 if (!(flags & TDF_SLIM))
881 if (BIND_EXPR_VARS (node))
885 for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
887 print_declaration (buffer, op0, spc+2, flags);
892 newline_and_indent (buffer, spc+2);
893 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
894 newline_and_indent (buffer, spc);
895 pp_character (buffer, '}');
901 print_call_name (buffer, node);
903 /* Print parameters. */
905 pp_character (buffer, '(');
906 op1 = TREE_OPERAND (node, 1);
908 dump_generic_node (buffer, op1, spc, flags, false);
909 pp_character (buffer, ')');
911 op1 = TREE_OPERAND (node, 2);
914 pp_string (buffer, " [static-chain: ");
915 dump_generic_node (buffer, op1, spc, flags, false);
916 pp_character (buffer, ']');
919 if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (node))
920 pp_string (buffer, " [return slot addr]");
921 if (CALL_EXPR_TAILCALL (node))
922 pp_string (buffer, " [tail call]");
925 case WITH_CLEANUP_EXPR:
929 case CLEANUP_POINT_EXPR:
930 pp_string (buffer, "<<cleanup_point ");
931 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
932 pp_string (buffer, ">>");
935 case PLACEHOLDER_EXPR:
936 pp_string (buffer, "<PLACEHOLDER_EXPR ");
937 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
938 pp_character (buffer, '>');
941 /* Binary arithmetic and logic expressions. */
962 case TRUTH_ANDIF_EXPR:
963 case TRUTH_ORIF_EXPR:
982 const char *op = op_symbol (node);
983 op0 = TREE_OPERAND (node, 0);
984 op1 = TREE_OPERAND (node, 1);
986 /* When the operands are expressions with less priority,
987 keep semantics of the tree representation. */
988 if (op_prio (op0) < op_prio (node))
990 pp_character (buffer, '(');
991 dump_generic_node (buffer, op0, spc, flags, false);
992 pp_character (buffer, ')');
995 dump_generic_node (buffer, op0, spc, flags, false);
998 pp_string (buffer, op);
1001 /* When the operands are expressions with less priority,
1002 keep semantics of the tree representation. */
1003 if (op_prio (op1) < op_prio (node))
1005 pp_character (buffer, '(');
1006 dump_generic_node (buffer, op1, spc, flags, false);
1007 pp_character (buffer, ')');
1010 dump_generic_node (buffer, op1, spc, flags, false);
1014 /* Unary arithmetic and logic expressions. */
1017 case TRUTH_NOT_EXPR:
1019 case PREDECREMENT_EXPR:
1020 case PREINCREMENT_EXPR:
1022 if (TREE_CODE (node) == ADDR_EXPR
1023 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1024 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1025 ; /* Do not output '&' for strings and function pointers. */
1027 pp_string (buffer, op_symbol (node));
1029 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1031 pp_character (buffer, '(');
1032 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1033 pp_character (buffer, ')');
1036 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1039 case POSTDECREMENT_EXPR:
1040 case POSTINCREMENT_EXPR:
1041 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1043 pp_character (buffer, '(');
1044 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1045 pp_character (buffer, ')');
1048 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1049 pp_string (buffer, op_symbol (node));
1053 pp_string (buffer, "MIN_EXPR <");
1054 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1055 pp_string (buffer, ", ");
1056 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1057 pp_character (buffer, '>');
1061 pp_string (buffer, "MAX_EXPR <");
1062 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1063 pp_string (buffer, ", ");
1064 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1065 pp_character (buffer, '>');
1069 pp_string (buffer, "ABS_EXPR <");
1070 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1071 pp_character (buffer, '>');
1078 case FIX_TRUNC_EXPR:
1080 case FIX_FLOOR_EXPR:
1081 case FIX_ROUND_EXPR:
1085 type = TREE_TYPE (node);
1086 op0 = TREE_OPERAND (node, 0);
1087 if (type != TREE_TYPE (op0))
1089 pp_character (buffer, '(');
1090 dump_generic_node (buffer, type, spc, flags, false);
1091 pp_string (buffer, ") ");
1093 if (op_prio (op0) < op_prio (node))
1094 pp_character (buffer, '(');
1095 dump_generic_node (buffer, op0, spc, flags, false);
1096 if (op_prio (op0) < op_prio (node))
1097 pp_character (buffer, ')');
1100 case VIEW_CONVERT_EXPR:
1101 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1102 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1103 pp_string (buffer, ">(");
1104 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1105 pp_character (buffer, ')');
1108 case NON_LVALUE_EXPR:
1109 pp_string (buffer, "NON_LVALUE_EXPR <");
1110 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1111 pp_character (buffer, '>');
1115 pp_string (buffer, "SAVE_EXPR <");
1116 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1117 pp_character (buffer, '>');
1121 pp_string (buffer, "COMPLEX_EXPR <");
1122 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1123 pp_string (buffer, ", ");
1124 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1125 pp_string (buffer, ">");
1129 pp_string (buffer, "CONJ_EXPR <");
1130 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1131 pp_string (buffer, ">");
1135 pp_string (buffer, "REALPART_EXPR <");
1136 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1137 pp_string (buffer, ">");
1141 pp_string (buffer, "IMAGPART_EXPR <");
1142 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1143 pp_string (buffer, ">");
1147 pp_string (buffer, "VA_ARG_EXPR <");
1148 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1149 pp_string (buffer, ">");
1152 case TRY_FINALLY_EXPR:
1153 case TRY_CATCH_EXPR:
1154 pp_string (buffer, "try");
1155 newline_and_indent (buffer, spc+2);
1156 pp_string (buffer, "{");
1157 newline_and_indent (buffer, spc+4);
1158 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1159 newline_and_indent (buffer, spc+2);
1160 pp_string (buffer, "}");
1161 newline_and_indent (buffer, spc);
1163 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1164 newline_and_indent (buffer, spc+2);
1165 pp_string (buffer, "{");
1166 newline_and_indent (buffer, spc+4);
1167 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1168 newline_and_indent (buffer, spc+2);
1169 pp_string (buffer, "}");
1174 pp_string (buffer, "catch (");
1175 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1176 pp_string (buffer, ")");
1177 newline_and_indent (buffer, spc+2);
1178 pp_string (buffer, "{");
1179 newline_and_indent (buffer, spc+4);
1180 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1181 newline_and_indent (buffer, spc+2);
1182 pp_string (buffer, "}");
1186 case EH_FILTER_EXPR:
1187 pp_string (buffer, "<<<eh_filter (");
1188 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1189 pp_string (buffer, ")>>>");
1190 newline_and_indent (buffer, spc+2);
1191 pp_string (buffer, "{");
1192 newline_and_indent (buffer, spc+4);
1193 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1194 newline_and_indent (buffer, spc+2);
1195 pp_string (buffer, "}");
1200 op0 = TREE_OPERAND (node, 0);
1201 /* If this is for break or continue, don't bother printing it. */
1202 if (DECL_NAME (op0))
1204 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1205 if (strcmp (name, "break") == 0
1206 || strcmp (name, "continue") == 0)
1209 dump_generic_node (buffer, op0, spc, flags, false);
1210 pp_character (buffer, ':');
1211 if (DECL_NONLOCAL (op0))
1212 pp_string (buffer, " [non-local]");
1215 case LABELED_BLOCK_EXPR:
1216 op0 = LABELED_BLOCK_LABEL (node);
1217 /* If this is for break or continue, don't bother printing it. */
1218 if (DECL_NAME (op0))
1220 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1221 if (strcmp (name, "break") == 0
1222 || strcmp (name, "continue") == 0)
1224 dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc, flags, false);
1228 dump_generic_node (buffer, LABELED_BLOCK_LABEL (node), spc, flags, false);
1229 pp_string (buffer, ": {");
1230 if (!(flags & TDF_SLIM))
1231 newline_and_indent (buffer, spc+2);
1232 dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc+2, flags, true);
1234 newline_and_indent (buffer, spc);
1235 pp_character (buffer, '}');
1239 case EXIT_BLOCK_EXPR:
1240 op0 = LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (node));
1241 /* If this is for a break or continue, print it accordingly. */
1242 if (DECL_NAME (op0))
1244 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1245 if (strcmp (name, "break") == 0
1246 || strcmp (name, "continue") == 0)
1248 pp_string (buffer, name);
1252 pp_string (buffer, "<<<exit block ");
1253 dump_generic_node (buffer, op0, spc, flags, false);
1254 pp_string (buffer, ">>>");
1258 pp_string (buffer, "<<<exception object>>>");
1262 pp_string (buffer, "<<<filter object>>>");
1266 pp_string (buffer, "while (1)");
1267 if (!(flags & TDF_SLIM))
1269 newline_and_indent (buffer, spc+2);
1270 pp_character (buffer, '{');
1271 newline_and_indent (buffer, spc+4);
1272 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1273 newline_and_indent (buffer, spc+2);
1274 pp_character (buffer, '}');
1280 pp_string (buffer, "return");
1281 op0 = TREE_OPERAND (node, 0);
1285 if (TREE_CODE (op0) == MODIFY_EXPR)
1286 dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);
1288 dump_generic_node (buffer, op0, spc, flags, false);
1293 pp_string (buffer, "if (");
1294 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1295 pp_string (buffer, ") break");
1299 pp_string (buffer, "switch (");
1300 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1301 pp_character (buffer, ')');
1302 if (!(flags & TDF_SLIM))
1304 newline_and_indent (buffer, spc+2);
1305 pp_character (buffer, '{');
1306 if (SWITCH_BODY (node))
1308 newline_and_indent (buffer, spc+4);
1309 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags, true);
1313 tree vec = SWITCH_LABELS (node);
1314 size_t i, n = TREE_VEC_LENGTH (vec);
1315 for (i = 0; i < n; ++i)
1317 tree elt = TREE_VEC_ELT (vec, i);
1318 newline_and_indent (buffer, spc+4);
1319 dump_generic_node (buffer, elt, spc+4, flags, false);
1320 pp_string (buffer, " goto ");
1321 dump_generic_node (buffer, CASE_LABEL (elt), spc+4, flags, true);
1322 pp_semicolon (buffer);
1325 newline_and_indent (buffer, spc+2);
1326 pp_character (buffer, '}');
1332 op0 = GOTO_DESTINATION (node);
1333 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1335 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1336 if (strcmp (name, "break") == 0
1337 || strcmp (name, "continue") == 0)
1339 pp_string (buffer, name);
1343 pp_string (buffer, "goto ");
1344 dump_generic_node (buffer, op0, spc, flags, false);
1348 pp_string (buffer, "resx");
1349 /* ??? Any sensible way to present the eh region? */
1353 pp_string (buffer, "__asm__");
1354 if (ASM_VOLATILE_P (node))
1355 pp_string (buffer, " __volatile__");
1356 pp_character (buffer, '(');
1357 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1358 pp_character (buffer, ':');
1359 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1360 pp_character (buffer, ':');
1361 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1362 if (ASM_CLOBBERS (node))
1364 pp_character (buffer, ':');
1365 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1367 pp_string (buffer, ")");
1370 case CASE_LABEL_EXPR:
1371 if (CASE_LOW (node) && CASE_HIGH (node))
1373 pp_string (buffer, "case ");
1374 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1375 pp_string (buffer, " ... ");
1376 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1378 else if (CASE_LOW (node))
1380 pp_string (buffer, "case ");
1381 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1384 pp_string (buffer, "default ");
1385 pp_character (buffer, ':');
1389 pp_string (buffer, "OBJ_TYPE_REF(");
1390 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1391 pp_character (buffer, ';');
1392 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1393 pp_character (buffer, '-');
1394 pp_character (buffer, '>');
1395 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1396 pp_character (buffer, ')');
1403 dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1404 pp_string (buffer, " = PHI <");
1405 for (i = 0; i < PHI_NUM_ARGS (node); i++)
1407 dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1408 pp_string (buffer, "(");
1409 pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1410 pp_string (buffer, ")");
1411 if (i < PHI_NUM_ARGS (node) - 1)
1412 pp_string (buffer, ", ");
1414 pp_string (buffer, ">;");
1419 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1420 pp_string (buffer, "_");
1421 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1424 case WITH_SIZE_EXPR:
1425 pp_string (buffer, "WITH_SIZE_EXPR <");
1426 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1427 pp_string (buffer, ", ");
1428 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1429 pp_string (buffer, ">");
1433 pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1437 pp_string (buffer, "scev_known");
1440 case SCEV_NOT_KNOWN:
1441 pp_string (buffer, "scev_not_known");
1444 case POLYNOMIAL_CHREC:
1445 pp_string (buffer, "{");
1446 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1447 pp_string (buffer, ", +, ");
1448 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1449 pp_string (buffer, "}_");
1450 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1458 if (is_stmt && is_expr)
1459 pp_semicolon (buffer);
1460 pp_write_text_to_stream (buffer);
1465 /* Print the declaration of a variable. */
1468 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
1472 if (TREE_CODE (t) == TYPE_DECL)
1473 pp_string (buffer, "typedef ");
1475 if (DECL_REGISTER (t))
1476 pp_string (buffer, "register ");
1478 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
1479 pp_string (buffer, "extern ");
1480 else if (TREE_STATIC (t))
1481 pp_string (buffer, "static ");
1483 /* Print the type and name. */
1484 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
1488 /* Print array's type. */
1489 tmp = TREE_TYPE (t);
1490 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
1491 tmp = TREE_TYPE (tmp);
1492 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
1494 /* Print variable's name. */
1496 dump_generic_node (buffer, t, spc, flags, false);
1498 /* Print the dimensions. */
1499 tmp = TREE_TYPE (t);
1500 while (TREE_CODE (tmp) == ARRAY_TYPE)
1502 pp_character (buffer, '[');
1503 if (TYPE_DOMAIN (tmp))
1505 if (TREE_CODE (TYPE_SIZE (tmp)) == INTEGER_CST)
1506 pp_wide_integer (buffer,
1507 TREE_INT_CST_LOW (TYPE_SIZE (tmp)) /
1508 TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tmp))));
1510 dump_generic_node (buffer, TYPE_SIZE_UNIT (tmp), spc, flags,
1513 pp_character (buffer, ']');
1514 tmp = TREE_TYPE (tmp);
1517 else if (TREE_CODE (t) == FUNCTION_DECL)
1519 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
1521 dump_decl_name (buffer, t, flags);
1522 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
1526 /* Print type declaration. */
1527 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
1529 /* Print variable's name. */
1531 dump_generic_node (buffer, t, spc, flags, false);
1534 /* The initial value of a function serves to determine wether the function
1535 is declared or defined. So the following does not apply to function
1537 if (TREE_CODE (t) != FUNCTION_DECL)
1539 /* Print the initial value. */
1540 if (DECL_INITIAL (t))
1543 pp_character (buffer, '=');
1545 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
1549 pp_character (buffer, ';');
1553 /* Prints a structure: name, fields, and methods.
1554 FIXME: Still incomplete. */
1557 print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
1559 /* Print the name of the structure. */
1560 if (TYPE_NAME (node))
1563 if (TREE_CODE (node) == RECORD_TYPE)
1564 pp_string (buffer, "struct ");
1565 else if ((TREE_CODE (node) == UNION_TYPE
1566 || TREE_CODE (node) == QUAL_UNION_TYPE))
1567 pp_string (buffer, "union ");
1569 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
1572 /* Print the contents of the structure. */
1573 pp_newline (buffer);
1575 pp_character (buffer, '{');
1576 pp_newline (buffer);
1578 /* Print the fields of the structure. */
1581 tmp = TYPE_FIELDS (node);
1584 /* Avoid to print recursively the structure. */
1585 /* FIXME : Not implemented correctly...,
1586 what about the case when we have a cycle in the contain graph? ...
1587 Maybe this could be solved by looking at the scope in which the
1588 structure was declared. */
1589 if (TREE_TYPE (tmp) != node
1590 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
1591 && TREE_TYPE (TREE_TYPE (tmp)) != node))
1593 print_declaration (buffer, tmp, spc+2, flags);
1594 pp_newline (buffer);
1596 tmp = TREE_CHAIN (tmp);
1600 pp_character (buffer, '}');
1603 /* Return the priority of the operator OP.
1605 From lowest to highest precedence with either left-to-right (L-R)
1606 or right-to-left (R-L) associativity]:
1609 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
1621 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
1622 15 [L-R] fn() [] -> .
1624 unary +, - and * have higher precedence than the corresponding binary
1633 switch (TREE_CODE (op))
1648 case TRUTH_ORIF_EXPR:
1651 case TRUTH_AND_EXPR:
1652 case TRUTH_ANDIF_EXPR:
1659 case TRUTH_XOR_EXPR:
1676 case UNORDERED_EXPR:
1694 case TRUNC_DIV_EXPR:
1696 case FLOOR_DIV_EXPR:
1697 case ROUND_DIV_EXPR:
1699 case EXACT_DIV_EXPR:
1700 case TRUNC_MOD_EXPR:
1702 case FLOOR_MOD_EXPR:
1703 case ROUND_MOD_EXPR:
1706 case TRUTH_NOT_EXPR:
1708 case POSTINCREMENT_EXPR:
1709 case POSTDECREMENT_EXPR:
1710 case PREINCREMENT_EXPR:
1711 case PREDECREMENT_EXPR:
1718 case FIX_TRUNC_EXPR:
1720 case FIX_FLOOR_EXPR:
1721 case FIX_ROUND_EXPR:
1727 case ARRAY_RANGE_REF:
1731 /* Special expressions. */
1740 case NON_LVALUE_EXPR:
1741 return op_prio (TREE_OPERAND (op, 0));
1744 /* Return an arbitrarily high precedence to avoid surrounding single
1745 VAR_DECLs in ()s. */
1751 /* Return the symbol associated with operator OP. */
1758 switch (TREE_CODE (op))
1764 case TRUTH_ORIF_EXPR:
1767 case TRUTH_AND_EXPR:
1768 case TRUTH_ANDIF_EXPR:
1774 case TRUTH_XOR_EXPR:
1784 case UNORDERED_EXPR:
1834 case TRUTH_NOT_EXPR:
1841 case TRUNC_DIV_EXPR:
1848 case FLOOR_DIV_EXPR:
1851 case ROUND_DIV_EXPR:
1854 case EXACT_DIV_EXPR:
1857 case TRUNC_MOD_EXPR:
1863 case FLOOR_MOD_EXPR:
1866 case ROUND_MOD_EXPR:
1869 case PREDECREMENT_EXPR:
1872 case PREINCREMENT_EXPR:
1875 case POSTDECREMENT_EXPR:
1878 case POSTINCREMENT_EXPR:
1882 return "<<< ??? >>>";
1886 /* Prints the name of a CALL_EXPR. */
1889 print_call_name (pretty_printer *buffer, tree node)
1893 gcc_assert (TREE_CODE (node) == CALL_EXPR);
1895 op0 = TREE_OPERAND (node, 0);
1897 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
1898 op0 = TREE_OPERAND (op0, 0);
1900 switch (TREE_CODE (op0))
1904 dump_function_name (buffer, op0);
1910 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1914 pp_string (buffer, "(");
1915 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1916 pp_string (buffer, ") ? ");
1917 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
1918 pp_string (buffer, " : ");
1919 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
1923 /* The function is a pointer contained in a structure. */
1924 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
1925 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
1926 dump_function_name (buffer, TREE_OPERAND (op0, 1));
1928 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1930 We can have several levels of structures and a function
1931 pointer inside. This is not implemented yet... */
1936 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
1937 dump_function_name (buffer, TREE_OPERAND (op0, 0));
1939 dump_generic_node (buffer, op0, 0, 0, false);
1944 dump_generic_node (buffer, op0, 0, 0, false);
1952 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
1955 pretty_print_string (pretty_printer *buffer, const char *str)
1965 pp_string (buffer, "\\b");
1969 pp_string (buffer, "\\f");
1973 pp_string (buffer, "\\n");
1977 pp_string (buffer, "\\r");
1981 pp_string (buffer, "\\t");
1985 pp_string (buffer, "\\v");
1989 pp_string (buffer, "\\\\");
1993 pp_string (buffer, "\\\"");
1997 pp_string (buffer, "\\'");
2001 pp_string (buffer, "\\0");
2005 pp_string (buffer, "\\1");
2009 pp_string (buffer, "\\2");
2013 pp_string (buffer, "\\3");
2017 pp_string (buffer, "\\4");
2021 pp_string (buffer, "\\5");
2025 pp_string (buffer, "\\6");
2029 pp_string (buffer, "\\7");
2033 pp_character (buffer, str[0]);
2041 maybe_init_pretty_print (FILE *file)
2045 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2046 pp_needs_newline (&buffer) = true;
2050 buffer.buffer->stream = file;
2054 newline_and_indent (pretty_printer *buffer, int spc)
2056 pp_newline (buffer);
2061 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2064 use_operand_p use_p;
2065 def_operand_p def_p;
2068 FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
2070 pp_string (buffer, "# ");
2071 dump_generic_node (buffer, DEF_FROM_PTR (def_p),
2072 spc + 2, flags, false);
2073 pp_string (buffer, " = V_MAY_DEF <");
2074 dump_generic_node (buffer, USE_FROM_PTR (use_p),
2075 spc + 2, flags, false);
2076 pp_string (buffer, ">;");
2077 newline_and_indent (buffer, spc);
2080 FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMUSTDEF)
2082 pp_string (buffer, "# V_MUST_DEF <");
2083 dump_generic_node (buffer, def, spc + 2, flags, false);
2084 pp_string (buffer, ">;");
2085 newline_and_indent (buffer, spc);
2088 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)
2090 pp_string (buffer, "# VUSE <");
2091 dump_generic_node (buffer, use, spc + 2, flags, false);
2092 pp_string (buffer, ">;");
2093 newline_and_indent (buffer, spc);
2097 /* Dumps basic block BB to FILE with details described by FLAGS and
2098 indented by INDENT spaces. */
2101 dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2103 maybe_init_pretty_print (file);
2104 dumping_stmts = true;
2105 dump_generic_bb_buff (&buffer, bb, indent, flags);
2109 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2110 spaces and details described by flags. */
2113 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2118 if (flags & TDF_BLOCKS)
2121 pp_string (buffer, "# BLOCK ");
2122 pp_decimal_int (buffer, bb->index);
2124 if (flags & TDF_LINENO)
2126 block_stmt_iterator bsi;
2128 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2129 if (get_lineno (bsi_stmt (bsi)) != -1)
2131 pp_string (buffer, ", starting at line ");
2132 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2136 newline_and_indent (buffer, indent);
2138 pp_string (buffer, "# PRED:");
2139 pp_write_text_to_stream (buffer);
2140 for (e = bb->pred; e; e = e->pred_next)
2141 if (flags & TDF_SLIM)
2143 pp_string (buffer, " ");
2144 if (e->src == ENTRY_BLOCK_PTR)
2145 pp_string (buffer, "ENTRY");
2147 pp_decimal_int (buffer, e->src->index);
2150 dump_edge_info (buffer->buffer->stream, e, 0);
2151 pp_newline (buffer);
2155 stmt = first_stmt (bb);
2156 if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
2158 INDENT (indent - 2);
2159 pp_string (buffer, "<bb ");
2160 pp_decimal_int (buffer, bb->index);
2161 pp_string (buffer, ">:");
2162 pp_newline (buffer);
2165 pp_write_text_to_stream (buffer);
2166 check_bb_profile (bb, buffer->buffer->stream);
2169 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2173 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
2178 pp_string (buffer, "# SUCC:");
2179 pp_write_text_to_stream (buffer);
2180 for (e = bb->succ; e; e = e->succ_next)
2181 if (flags & TDF_SLIM)
2183 pp_string (buffer, " ");
2184 if (e->dest == EXIT_BLOCK_PTR)
2185 pp_string (buffer, "EXIT");
2187 pp_decimal_int (buffer, e->dest->index);
2190 dump_edge_info (buffer->buffer->stream, e, 1);
2191 pp_newline (buffer);
2194 /* Dumps phi nodes of basic block BB to buffer BUFFER with details described by
2195 FLAGS indented by INDENT spaces. */
2198 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
2200 tree phi = phi_nodes (bb);
2204 for (; phi; phi = PHI_CHAIN (phi))
2206 if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
2209 pp_string (buffer, "# ");
2210 dump_generic_node (buffer, phi, indent, flags, false);
2211 pp_newline (buffer);
2216 /* Dump jump to basic block BB that is represented implicitly in the cfg
2220 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
2224 stmt = first_stmt (bb);
2226 pp_string (buffer, "goto <bb ");
2227 pp_decimal_int (buffer, bb->index);
2228 pp_string (buffer, ">");
2229 if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
2231 pp_string (buffer, " (");
2232 dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
2233 pp_string (buffer, ")");
2235 pp_semicolon (buffer);
2238 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
2239 by INDENT spaces, with details given by FLAGS. */
2242 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
2247 /* If there is a fallthru edge, we may need to add an artificial goto to the
2249 for (e = bb->succ; e; e = e->succ_next)
2250 if (e->flags & EDGE_FALLTHRU)
2252 if (e && e->dest != bb->next_bb)
2256 if ((flags & TDF_LINENO)
2257 #ifdef USE_MAPPED_LOCATION
2258 && e->goto_locus != UNKNOWN_LOCATION
2264 expanded_location goto_xloc;
2265 #ifdef USE_MAPPED_LOCATION
2266 goto_xloc = expand_location (e->goto_locus);
2268 goto_xloc = *e->goto_locus;
2270 pp_character (buffer, '[');
2273 pp_string (buffer, goto_xloc.file);
2274 pp_string (buffer, " : ");
2276 pp_decimal_int (buffer, goto_xloc.line);
2277 pp_string (buffer, "] ");
2280 pp_cfg_jump (buffer, e->dest);
2281 pp_newline (buffer);
2285 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2286 indented by INDENT spaces. */
2289 dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
2290 int indent, int flags)
2292 block_stmt_iterator bsi;
2294 int label_indent = indent - 2;
2296 if (label_indent < 0)
2299 dump_bb_header (buffer, bb, indent, flags);
2302 dump_phi_nodes (buffer, bb, indent, flags);
2304 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2308 stmt = bsi_stmt (bsi);
2310 curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
2312 INDENT (curr_indent);
2313 dump_generic_node (buffer, stmt, curr_indent, flags, true);
2314 pp_newline (buffer);
2317 dump_implicit_edges (buffer, bb, indent, flags);
2319 if (flags & TDF_BLOCKS)
2320 dump_bb_end (buffer, bb, indent, flags);