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:
1021 case ALIGN_INDIRECT_REF:
1022 case MISALIGNED_INDIRECT_REF:
1024 if (TREE_CODE (node) == ADDR_EXPR
1025 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1026 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1027 ; /* Do not output '&' for strings and function pointers. */
1029 pp_string (buffer, op_symbol (node));
1031 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1033 pp_character (buffer, '(');
1034 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1035 pp_character (buffer, ')');
1038 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1040 if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1042 pp_string (buffer, "{misalignment: ");
1043 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1044 pp_character (buffer, '}');
1048 case POSTDECREMENT_EXPR:
1049 case POSTINCREMENT_EXPR:
1050 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1052 pp_character (buffer, '(');
1053 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1054 pp_character (buffer, ')');
1057 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1058 pp_string (buffer, op_symbol (node));
1062 pp_string (buffer, "MIN_EXPR <");
1063 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1064 pp_string (buffer, ", ");
1065 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1066 pp_character (buffer, '>');
1070 pp_string (buffer, "MAX_EXPR <");
1071 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1072 pp_string (buffer, ", ");
1073 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1074 pp_character (buffer, '>');
1078 pp_string (buffer, "ABS_EXPR <");
1079 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1080 pp_character (buffer, '>');
1087 case FIX_TRUNC_EXPR:
1089 case FIX_FLOOR_EXPR:
1090 case FIX_ROUND_EXPR:
1094 type = TREE_TYPE (node);
1095 op0 = TREE_OPERAND (node, 0);
1096 if (type != TREE_TYPE (op0))
1098 pp_character (buffer, '(');
1099 dump_generic_node (buffer, type, spc, flags, false);
1100 pp_string (buffer, ") ");
1102 if (op_prio (op0) < op_prio (node))
1103 pp_character (buffer, '(');
1104 dump_generic_node (buffer, op0, spc, flags, false);
1105 if (op_prio (op0) < op_prio (node))
1106 pp_character (buffer, ')');
1109 case VIEW_CONVERT_EXPR:
1110 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1111 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1112 pp_string (buffer, ">(");
1113 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1114 pp_character (buffer, ')');
1117 case NON_LVALUE_EXPR:
1118 pp_string (buffer, "NON_LVALUE_EXPR <");
1119 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1120 pp_character (buffer, '>');
1124 pp_string (buffer, "SAVE_EXPR <");
1125 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1126 pp_character (buffer, '>');
1130 pp_string (buffer, "COMPLEX_EXPR <");
1131 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1132 pp_string (buffer, ", ");
1133 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1134 pp_string (buffer, ">");
1138 pp_string (buffer, "CONJ_EXPR <");
1139 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1140 pp_string (buffer, ">");
1144 pp_string (buffer, "REALPART_EXPR <");
1145 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1146 pp_string (buffer, ">");
1150 pp_string (buffer, "IMAGPART_EXPR <");
1151 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1152 pp_string (buffer, ">");
1156 pp_string (buffer, "VA_ARG_EXPR <");
1157 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1158 pp_string (buffer, ">");
1161 case TRY_FINALLY_EXPR:
1162 case TRY_CATCH_EXPR:
1163 pp_string (buffer, "try");
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, 0), spc+4, flags, true);
1168 newline_and_indent (buffer, spc+2);
1169 pp_string (buffer, "}");
1170 newline_and_indent (buffer, spc);
1172 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1173 newline_and_indent (buffer, spc+2);
1174 pp_string (buffer, "{");
1175 newline_and_indent (buffer, spc+4);
1176 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1177 newline_and_indent (buffer, spc+2);
1178 pp_string (buffer, "}");
1183 pp_string (buffer, "catch (");
1184 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1185 pp_string (buffer, ")");
1186 newline_and_indent (buffer, spc+2);
1187 pp_string (buffer, "{");
1188 newline_and_indent (buffer, spc+4);
1189 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1190 newline_and_indent (buffer, spc+2);
1191 pp_string (buffer, "}");
1195 case EH_FILTER_EXPR:
1196 pp_string (buffer, "<<<eh_filter (");
1197 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1198 pp_string (buffer, ")>>>");
1199 newline_and_indent (buffer, spc+2);
1200 pp_string (buffer, "{");
1201 newline_and_indent (buffer, spc+4);
1202 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1203 newline_and_indent (buffer, spc+2);
1204 pp_string (buffer, "}");
1209 op0 = TREE_OPERAND (node, 0);
1210 /* If this is for break or continue, don't bother printing it. */
1211 if (DECL_NAME (op0))
1213 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1214 if (strcmp (name, "break") == 0
1215 || strcmp (name, "continue") == 0)
1218 dump_generic_node (buffer, op0, spc, flags, false);
1219 pp_character (buffer, ':');
1220 if (DECL_NONLOCAL (op0))
1221 pp_string (buffer, " [non-local]");
1224 case LABELED_BLOCK_EXPR:
1225 op0 = LABELED_BLOCK_LABEL (node);
1226 /* If this is for break or continue, don't bother printing it. */
1227 if (DECL_NAME (op0))
1229 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1230 if (strcmp (name, "break") == 0
1231 || strcmp (name, "continue") == 0)
1233 dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc, flags, false);
1237 dump_generic_node (buffer, LABELED_BLOCK_LABEL (node), spc, flags, false);
1238 pp_string (buffer, ": {");
1239 if (!(flags & TDF_SLIM))
1240 newline_and_indent (buffer, spc+2);
1241 dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc+2, flags, true);
1243 newline_and_indent (buffer, spc);
1244 pp_character (buffer, '}');
1248 case EXIT_BLOCK_EXPR:
1249 op0 = LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (node));
1250 /* If this is for a break or continue, print it accordingly. */
1251 if (DECL_NAME (op0))
1253 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1254 if (strcmp (name, "break") == 0
1255 || strcmp (name, "continue") == 0)
1257 pp_string (buffer, name);
1261 pp_string (buffer, "<<<exit block ");
1262 dump_generic_node (buffer, op0, spc, flags, false);
1263 pp_string (buffer, ">>>");
1267 pp_string (buffer, "<<<exception object>>>");
1271 pp_string (buffer, "<<<filter object>>>");
1275 pp_string (buffer, "while (1)");
1276 if (!(flags & TDF_SLIM))
1278 newline_and_indent (buffer, spc+2);
1279 pp_character (buffer, '{');
1280 newline_and_indent (buffer, spc+4);
1281 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1282 newline_and_indent (buffer, spc+2);
1283 pp_character (buffer, '}');
1289 pp_string (buffer, "return");
1290 op0 = TREE_OPERAND (node, 0);
1294 if (TREE_CODE (op0) == MODIFY_EXPR)
1295 dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);
1297 dump_generic_node (buffer, op0, spc, flags, false);
1302 pp_string (buffer, "if (");
1303 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1304 pp_string (buffer, ") break");
1308 pp_string (buffer, "switch (");
1309 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1310 pp_character (buffer, ')');
1311 if (!(flags & TDF_SLIM))
1313 newline_and_indent (buffer, spc+2);
1314 pp_character (buffer, '{');
1315 if (SWITCH_BODY (node))
1317 newline_and_indent (buffer, spc+4);
1318 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags, true);
1322 tree vec = SWITCH_LABELS (node);
1323 size_t i, n = TREE_VEC_LENGTH (vec);
1324 for (i = 0; i < n; ++i)
1326 tree elt = TREE_VEC_ELT (vec, i);
1327 newline_and_indent (buffer, spc+4);
1328 dump_generic_node (buffer, elt, spc+4, flags, false);
1329 pp_string (buffer, " goto ");
1330 dump_generic_node (buffer, CASE_LABEL (elt), spc+4, flags, true);
1331 pp_semicolon (buffer);
1334 newline_and_indent (buffer, spc+2);
1335 pp_character (buffer, '}');
1341 op0 = GOTO_DESTINATION (node);
1342 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1344 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1345 if (strcmp (name, "break") == 0
1346 || strcmp (name, "continue") == 0)
1348 pp_string (buffer, name);
1352 pp_string (buffer, "goto ");
1353 dump_generic_node (buffer, op0, spc, flags, false);
1357 pp_string (buffer, "resx");
1358 /* ??? Any sensible way to present the eh region? */
1362 pp_string (buffer, "__asm__");
1363 if (ASM_VOLATILE_P (node))
1364 pp_string (buffer, " __volatile__");
1365 pp_character (buffer, '(');
1366 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1367 pp_character (buffer, ':');
1368 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1369 pp_character (buffer, ':');
1370 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1371 if (ASM_CLOBBERS (node))
1373 pp_character (buffer, ':');
1374 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1376 pp_string (buffer, ")");
1379 case CASE_LABEL_EXPR:
1380 if (CASE_LOW (node) && CASE_HIGH (node))
1382 pp_string (buffer, "case ");
1383 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1384 pp_string (buffer, " ... ");
1385 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1387 else if (CASE_LOW (node))
1389 pp_string (buffer, "case ");
1390 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1393 pp_string (buffer, "default ");
1394 pp_character (buffer, ':');
1398 pp_string (buffer, "OBJ_TYPE_REF(");
1399 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1400 pp_character (buffer, ';');
1401 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1402 pp_character (buffer, '-');
1403 pp_character (buffer, '>');
1404 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1405 pp_character (buffer, ')');
1412 dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1413 pp_string (buffer, " = PHI <");
1414 for (i = 0; i < PHI_NUM_ARGS (node); i++)
1416 dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1417 pp_string (buffer, "(");
1418 pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1419 pp_string (buffer, ")");
1420 if (i < PHI_NUM_ARGS (node) - 1)
1421 pp_string (buffer, ", ");
1423 pp_string (buffer, ">;");
1428 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1429 pp_string (buffer, "_");
1430 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1433 case WITH_SIZE_EXPR:
1434 pp_string (buffer, "WITH_SIZE_EXPR <");
1435 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1436 pp_string (buffer, ", ");
1437 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1438 pp_string (buffer, ">");
1442 pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1446 pp_string (buffer, "scev_known");
1449 case SCEV_NOT_KNOWN:
1450 pp_string (buffer, "scev_not_known");
1453 case POLYNOMIAL_CHREC:
1454 pp_string (buffer, "{");
1455 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1456 pp_string (buffer, ", +, ");
1457 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1458 pp_string (buffer, "}_");
1459 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1463 case REALIGN_LOAD_EXPR:
1464 pp_string (buffer, "REALIGN_LOAD <");
1465 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1466 pp_string (buffer, ", ");
1467 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1468 pp_string (buffer, ", ");
1469 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1470 pp_string (buffer, ">");
1474 pp_string (buffer, " VEC_COND_EXPR < ");
1475 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1476 pp_string (buffer, " , ");
1477 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1478 pp_string (buffer, " , ");
1479 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1480 pp_string (buffer, " > ");
1487 if (is_stmt && is_expr)
1488 pp_semicolon (buffer);
1489 pp_write_text_to_stream (buffer);
1494 /* Print the declaration of a variable. */
1497 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
1501 if (TREE_CODE (t) == TYPE_DECL)
1502 pp_string (buffer, "typedef ");
1504 if (DECL_REGISTER (t))
1505 pp_string (buffer, "register ");
1507 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
1508 pp_string (buffer, "extern ");
1509 else if (TREE_STATIC (t))
1510 pp_string (buffer, "static ");
1512 /* Print the type and name. */
1513 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
1517 /* Print array's type. */
1518 tmp = TREE_TYPE (t);
1519 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
1520 tmp = TREE_TYPE (tmp);
1521 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
1523 /* Print variable's name. */
1525 dump_generic_node (buffer, t, spc, flags, false);
1527 /* Print the dimensions. */
1528 tmp = TREE_TYPE (t);
1529 while (TREE_CODE (tmp) == ARRAY_TYPE)
1531 pp_character (buffer, '[');
1532 if (TYPE_DOMAIN (tmp))
1534 if (TREE_CODE (TYPE_SIZE (tmp)) == INTEGER_CST)
1535 pp_wide_integer (buffer,
1536 TREE_INT_CST_LOW (TYPE_SIZE (tmp)) /
1537 TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tmp))));
1539 dump_generic_node (buffer, TYPE_SIZE_UNIT (tmp), spc, flags,
1542 pp_character (buffer, ']');
1543 tmp = TREE_TYPE (tmp);
1546 else if (TREE_CODE (t) == FUNCTION_DECL)
1548 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
1550 dump_decl_name (buffer, t, flags);
1551 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
1555 /* Print type declaration. */
1556 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
1558 /* Print variable's name. */
1560 dump_generic_node (buffer, t, spc, flags, false);
1563 /* The initial value of a function serves to determine wether the function
1564 is declared or defined. So the following does not apply to function
1566 if (TREE_CODE (t) != FUNCTION_DECL)
1568 /* Print the initial value. */
1569 if (DECL_INITIAL (t))
1572 pp_character (buffer, '=');
1574 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
1578 pp_character (buffer, ';');
1582 /* Prints a structure: name, fields, and methods.
1583 FIXME: Still incomplete. */
1586 print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
1588 /* Print the name of the structure. */
1589 if (TYPE_NAME (node))
1592 if (TREE_CODE (node) == RECORD_TYPE)
1593 pp_string (buffer, "struct ");
1594 else if ((TREE_CODE (node) == UNION_TYPE
1595 || TREE_CODE (node) == QUAL_UNION_TYPE))
1596 pp_string (buffer, "union ");
1598 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
1601 /* Print the contents of the structure. */
1602 pp_newline (buffer);
1604 pp_character (buffer, '{');
1605 pp_newline (buffer);
1607 /* Print the fields of the structure. */
1610 tmp = TYPE_FIELDS (node);
1613 /* Avoid to print recursively the structure. */
1614 /* FIXME : Not implemented correctly...,
1615 what about the case when we have a cycle in the contain graph? ...
1616 Maybe this could be solved by looking at the scope in which the
1617 structure was declared. */
1618 if (TREE_TYPE (tmp) != node
1619 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
1620 && TREE_TYPE (TREE_TYPE (tmp)) != node))
1622 print_declaration (buffer, tmp, spc+2, flags);
1623 pp_newline (buffer);
1625 tmp = TREE_CHAIN (tmp);
1629 pp_character (buffer, '}');
1632 /* Return the priority of the operator OP.
1634 From lowest to highest precedence with either left-to-right (L-R)
1635 or right-to-left (R-L) associativity]:
1638 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
1650 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
1651 15 [L-R] fn() [] -> .
1653 unary +, - and * have higher precedence than the corresponding binary
1662 switch (TREE_CODE (op))
1677 case TRUTH_ORIF_EXPR:
1680 case TRUTH_AND_EXPR:
1681 case TRUTH_ANDIF_EXPR:
1688 case TRUTH_XOR_EXPR:
1705 case UNORDERED_EXPR:
1723 case TRUNC_DIV_EXPR:
1725 case FLOOR_DIV_EXPR:
1726 case ROUND_DIV_EXPR:
1728 case EXACT_DIV_EXPR:
1729 case TRUNC_MOD_EXPR:
1731 case FLOOR_MOD_EXPR:
1732 case ROUND_MOD_EXPR:
1735 case TRUTH_NOT_EXPR:
1737 case POSTINCREMENT_EXPR:
1738 case POSTDECREMENT_EXPR:
1739 case PREINCREMENT_EXPR:
1740 case PREDECREMENT_EXPR:
1742 case ALIGN_INDIRECT_REF:
1743 case MISALIGNED_INDIRECT_REF:
1749 case FIX_TRUNC_EXPR:
1751 case FIX_FLOOR_EXPR:
1752 case FIX_ROUND_EXPR:
1758 case ARRAY_RANGE_REF:
1762 /* Special expressions. */
1771 case NON_LVALUE_EXPR:
1772 return op_prio (TREE_OPERAND (op, 0));
1775 /* Return an arbitrarily high precedence to avoid surrounding single
1776 VAR_DECLs in ()s. */
1782 /* Return the symbol associated with operator OP. */
1789 switch (TREE_CODE (op))
1795 case TRUTH_ORIF_EXPR:
1798 case TRUTH_AND_EXPR:
1799 case TRUTH_ANDIF_EXPR:
1805 case TRUTH_XOR_EXPR:
1815 case UNORDERED_EXPR:
1865 case TRUTH_NOT_EXPR:
1872 case ALIGN_INDIRECT_REF:
1875 case MISALIGNED_INDIRECT_REF:
1878 case TRUNC_DIV_EXPR:
1885 case FLOOR_DIV_EXPR:
1888 case ROUND_DIV_EXPR:
1891 case EXACT_DIV_EXPR:
1894 case TRUNC_MOD_EXPR:
1900 case FLOOR_MOD_EXPR:
1903 case ROUND_MOD_EXPR:
1906 case PREDECREMENT_EXPR:
1909 case PREINCREMENT_EXPR:
1912 case POSTDECREMENT_EXPR:
1915 case POSTINCREMENT_EXPR:
1919 return "<<< ??? >>>";
1923 /* Prints the name of a CALL_EXPR. */
1926 print_call_name (pretty_printer *buffer, tree node)
1930 gcc_assert (TREE_CODE (node) == CALL_EXPR);
1932 op0 = TREE_OPERAND (node, 0);
1934 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
1935 op0 = TREE_OPERAND (op0, 0);
1937 switch (TREE_CODE (op0))
1941 dump_function_name (buffer, op0);
1947 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1951 pp_string (buffer, "(");
1952 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1953 pp_string (buffer, ") ? ");
1954 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
1955 pp_string (buffer, " : ");
1956 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
1960 /* The function is a pointer contained in a structure. */
1961 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
1962 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
1963 dump_function_name (buffer, TREE_OPERAND (op0, 1));
1965 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1967 We can have several levels of structures and a function
1968 pointer inside. This is not implemented yet... */
1973 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
1974 dump_function_name (buffer, TREE_OPERAND (op0, 0));
1976 dump_generic_node (buffer, op0, 0, 0, false);
1981 dump_generic_node (buffer, op0, 0, 0, false);
1989 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
1992 pretty_print_string (pretty_printer *buffer, const char *str)
2002 pp_string (buffer, "\\b");
2006 pp_string (buffer, "\\f");
2010 pp_string (buffer, "\\n");
2014 pp_string (buffer, "\\r");
2018 pp_string (buffer, "\\t");
2022 pp_string (buffer, "\\v");
2026 pp_string (buffer, "\\\\");
2030 pp_string (buffer, "\\\"");
2034 pp_string (buffer, "\\'");
2038 pp_string (buffer, "\\0");
2042 pp_string (buffer, "\\1");
2046 pp_string (buffer, "\\2");
2050 pp_string (buffer, "\\3");
2054 pp_string (buffer, "\\4");
2058 pp_string (buffer, "\\5");
2062 pp_string (buffer, "\\6");
2066 pp_string (buffer, "\\7");
2070 pp_character (buffer, str[0]);
2078 maybe_init_pretty_print (FILE *file)
2082 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2083 pp_needs_newline (&buffer) = true;
2087 buffer.buffer->stream = file;
2091 newline_and_indent (pretty_printer *buffer, int spc)
2093 pp_newline (buffer);
2098 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2101 use_operand_p use_p;
2102 def_operand_p def_p;
2105 FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
2107 pp_string (buffer, "# ");
2108 dump_generic_node (buffer, DEF_FROM_PTR (def_p),
2109 spc + 2, flags, false);
2110 pp_string (buffer, " = V_MAY_DEF <");
2111 dump_generic_node (buffer, USE_FROM_PTR (use_p),
2112 spc + 2, flags, false);
2113 pp_string (buffer, ">;");
2114 newline_and_indent (buffer, spc);
2117 FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMUSTDEF)
2119 pp_string (buffer, "# V_MUST_DEF <");
2120 dump_generic_node (buffer, def, spc + 2, flags, false);
2121 pp_string (buffer, ">;");
2122 newline_and_indent (buffer, spc);
2125 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)
2127 pp_string (buffer, "# VUSE <");
2128 dump_generic_node (buffer, use, spc + 2, flags, false);
2129 pp_string (buffer, ">;");
2130 newline_and_indent (buffer, spc);
2134 /* Dumps basic block BB to FILE with details described by FLAGS and
2135 indented by INDENT spaces. */
2138 dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2140 maybe_init_pretty_print (file);
2141 dumping_stmts = true;
2142 dump_generic_bb_buff (&buffer, bb, indent, flags);
2146 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2147 spaces and details described by flags. */
2150 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2155 if (flags & TDF_BLOCKS)
2158 pp_string (buffer, "# BLOCK ");
2159 pp_decimal_int (buffer, bb->index);
2161 if (flags & TDF_LINENO)
2163 block_stmt_iterator bsi;
2165 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2166 if (get_lineno (bsi_stmt (bsi)) != -1)
2168 pp_string (buffer, ", starting at line ");
2169 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2173 newline_and_indent (buffer, indent);
2175 pp_string (buffer, "# PRED:");
2176 pp_write_text_to_stream (buffer);
2177 for (e = bb->pred; e; e = e->pred_next)
2178 if (flags & TDF_SLIM)
2180 pp_string (buffer, " ");
2181 if (e->src == ENTRY_BLOCK_PTR)
2182 pp_string (buffer, "ENTRY");
2184 pp_decimal_int (buffer, e->src->index);
2187 dump_edge_info (buffer->buffer->stream, e, 0);
2188 pp_newline (buffer);
2192 stmt = first_stmt (bb);
2193 if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
2195 INDENT (indent - 2);
2196 pp_string (buffer, "<bb ");
2197 pp_decimal_int (buffer, bb->index);
2198 pp_string (buffer, ">:");
2199 pp_newline (buffer);
2202 pp_write_text_to_stream (buffer);
2203 check_bb_profile (bb, buffer->buffer->stream);
2206 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2210 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
2215 pp_string (buffer, "# SUCC:");
2216 pp_write_text_to_stream (buffer);
2217 for (e = bb->succ; e; e = e->succ_next)
2218 if (flags & TDF_SLIM)
2220 pp_string (buffer, " ");
2221 if (e->dest == EXIT_BLOCK_PTR)
2222 pp_string (buffer, "EXIT");
2224 pp_decimal_int (buffer, e->dest->index);
2227 dump_edge_info (buffer->buffer->stream, e, 1);
2228 pp_newline (buffer);
2231 /* Dumps phi nodes of basic block BB to buffer BUFFER with details described by
2232 FLAGS indented by INDENT spaces. */
2235 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
2237 tree phi = phi_nodes (bb);
2241 for (; phi; phi = PHI_CHAIN (phi))
2243 if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
2246 pp_string (buffer, "# ");
2247 dump_generic_node (buffer, phi, indent, flags, false);
2248 pp_newline (buffer);
2253 /* Dump jump to basic block BB that is represented implicitly in the cfg
2257 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
2261 stmt = first_stmt (bb);
2263 pp_string (buffer, "goto <bb ");
2264 pp_decimal_int (buffer, bb->index);
2265 pp_string (buffer, ">");
2266 if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
2268 pp_string (buffer, " (");
2269 dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
2270 pp_string (buffer, ")");
2272 pp_semicolon (buffer);
2275 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
2276 by INDENT spaces, with details given by FLAGS. */
2279 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
2284 /* If there is a fallthru edge, we may need to add an artificial goto to the
2286 for (e = bb->succ; e; e = e->succ_next)
2287 if (e->flags & EDGE_FALLTHRU)
2289 if (e && e->dest != bb->next_bb)
2293 if ((flags & TDF_LINENO)
2294 #ifdef USE_MAPPED_LOCATION
2295 && e->goto_locus != UNKNOWN_LOCATION
2301 expanded_location goto_xloc;
2302 #ifdef USE_MAPPED_LOCATION
2303 goto_xloc = expand_location (e->goto_locus);
2305 goto_xloc = *e->goto_locus;
2307 pp_character (buffer, '[');
2310 pp_string (buffer, goto_xloc.file);
2311 pp_string (buffer, " : ");
2313 pp_decimal_int (buffer, goto_xloc.line);
2314 pp_string (buffer, "] ");
2317 pp_cfg_jump (buffer, e->dest);
2318 pp_newline (buffer);
2322 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2323 indented by INDENT spaces. */
2326 dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
2327 int indent, int flags)
2329 block_stmt_iterator bsi;
2331 int label_indent = indent - 2;
2333 if (label_indent < 0)
2336 dump_bb_header (buffer, bb, indent, flags);
2339 dump_phi_nodes (buffer, bb, indent, flags);
2341 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2345 stmt = bsi_stmt (bsi);
2347 curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
2349 INDENT (curr_indent);
2350 dump_generic_node (buffer, stmt, curr_indent, flags, true);
2351 pp_newline (buffer);
2354 dump_implicit_edges (buffer, bb, indent, flags);
2356 if (flags & TDF_BLOCKS)
2357 dump_bb_end (buffer, bb, indent, flags);