1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
3 Free Software Foundation, Inc.
4 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
28 #include "diagnostic.h"
31 #include "tree-flow.h"
32 #include "langhooks.h"
33 #include "tree-iterator.h"
34 #include "tree-chrec.h"
35 #include "tree-pass.h"
36 #include "fixed-value.h"
37 #include "value-prof.h"
40 /* Local functions, macros and variables. */
41 static int op_prio (const_tree);
42 static const char *op_symbol (const_tree);
43 static void pretty_print_string (pretty_printer *, const char*);
44 static void print_call_name (pretty_printer *, const_tree);
45 static void newline_and_indent (pretty_printer *, int);
46 static void maybe_init_pretty_print (FILE *);
47 static void print_declaration (pretty_printer *, tree, int, int);
48 static void print_struct_decl (pretty_printer *, const_tree, int, int);
49 static void do_niy (pretty_printer *, const_tree);
50 static void dump_vops (pretty_printer *, tree, int, int);
51 static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
53 #define INDENT(SPACE) do { \
54 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
56 #define NIY do_niy(buffer,node)
58 #define PRINT_FUNCTION_NAME(NODE) pp_printf \
59 (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \
60 lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
61 lang_hooks.decl_printable_name (NODE, 1))
63 static pretty_printer buffer;
64 static int initialized = 0;
66 /* Try to print something for an unknown tree code. */
69 do_niy (pretty_printer *buffer, const_tree node)
73 pp_string (buffer, "<<< Unknown tree: ");
74 pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
78 len = TREE_OPERAND_LENGTH (node);
79 for (i = 0; i < len; ++i)
81 newline_and_indent (buffer, 2);
82 dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);
86 pp_string (buffer, " >>>\n");
89 /* Debugging function to print out a generic expression. */
92 debug_generic_expr (tree t)
94 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
95 fprintf (stderr, "\n");
98 /* Debugging function to print out a generic statement. */
101 debug_generic_stmt (tree t)
103 print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
104 fprintf (stderr, "\n");
107 /* Debugging function to print out a chain of trees . */
110 debug_tree_chain (tree t)
114 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
115 fprintf(stderr, " ");
118 fprintf (stderr, "\n");
121 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
123 print_generic_decl (FILE *file, tree decl, int flags)
125 maybe_init_pretty_print (file);
126 print_declaration (&buffer, decl, 2, flags);
127 pp_write_text_to_stream (&buffer);
130 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
131 to show in the dump. See TDF_* in tree-pass.h. */
134 print_generic_stmt (FILE *file, tree t, int flags)
136 maybe_init_pretty_print (file);
137 dump_generic_node (&buffer, t, 0, flags, true);
141 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
142 to show in the dump. See TDF_* in tree-pass.h. The output is indented by
146 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
150 maybe_init_pretty_print (file);
152 for (i = 0; i < indent; i++)
154 dump_generic_node (&buffer, t, indent, flags, true);
158 /* Print a single expression T on file FILE. FLAGS specifies details to show
159 in the dump. See TDF_* in tree-pass.h. */
162 print_generic_expr (FILE *file, tree t, int flags)
164 maybe_init_pretty_print (file);
165 dump_generic_node (&buffer, t, 0, flags, false);
168 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
172 dump_decl_name (pretty_printer *buffer, tree node, int flags)
177 pp_tree_identifier (buffer, DECL_NAME (t));
178 if ((flags & TDF_UID)
179 || DECL_NAME (t) == NULL_TREE)
181 if (TREE_CODE (t) == LABEL_DECL
182 && LABEL_DECL_UID (t) != -1)
183 pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (t));
186 char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
187 pp_printf (buffer, "%c.%u", c, DECL_UID (t));
192 /* Like the above, but used for pretty printing function calls. */
195 dump_function_name (pretty_printer *buffer, tree node)
197 if (DECL_NAME (node))
198 PRINT_FUNCTION_NAME (node);
200 dump_decl_name (buffer, node, 0);
203 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
204 FLAGS are as in dump_generic_node. */
207 dump_function_declaration (pretty_printer *buffer, tree node,
210 bool wrote_arg = false;
214 pp_character (buffer, '(');
216 /* Print the argument types. The last element in the list is a VOID_TYPE.
217 The following avoids printing the last element. */
218 arg = TYPE_ARG_TYPES (node);
219 while (arg && TREE_CHAIN (arg) && arg != error_mark_node)
222 dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
223 arg = TREE_CHAIN (arg);
224 if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)
226 pp_character (buffer, ',');
232 pp_string (buffer, "void");
234 pp_character (buffer, ')');
237 /* Dump the domain associated with an array. */
240 dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
242 pp_character (buffer, '[');
245 tree min = TYPE_MIN_VALUE (domain);
246 tree max = TYPE_MAX_VALUE (domain);
249 && integer_zerop (min)
250 && host_integerp (max, 0))
251 pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
255 dump_generic_node (buffer, min, spc, flags, false);
256 pp_character (buffer, ':');
258 dump_generic_node (buffer, max, spc, flags, false);
262 pp_string (buffer, "<unknown>");
263 pp_character (buffer, ']');
267 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
268 dump_generic_node. */
271 dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
275 switch (OMP_CLAUSE_CODE (clause))
277 case OMP_CLAUSE_PRIVATE:
280 case OMP_CLAUSE_SHARED:
283 case OMP_CLAUSE_FIRSTPRIVATE:
284 name = "firstprivate";
286 case OMP_CLAUSE_LASTPRIVATE:
287 name = "lastprivate";
289 case OMP_CLAUSE_COPYIN:
292 case OMP_CLAUSE_COPYPRIVATE:
293 name = "copyprivate";
296 pp_string (buffer, name);
297 pp_character (buffer, '(');
298 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
300 pp_character (buffer, ')');
303 case OMP_CLAUSE_REDUCTION:
304 pp_string (buffer, "reduction(");
305 pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
306 pp_character (buffer, ':');
307 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
309 pp_character (buffer, ')');
313 pp_string (buffer, "if(");
314 dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
316 pp_character (buffer, ')');
319 case OMP_CLAUSE_NUM_THREADS:
320 pp_string (buffer, "num_threads(");
321 dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
323 pp_character (buffer, ')');
326 case OMP_CLAUSE_NOWAIT:
327 pp_string (buffer, "nowait");
329 case OMP_CLAUSE_ORDERED:
330 pp_string (buffer, "ordered");
333 case OMP_CLAUSE_DEFAULT:
334 pp_string (buffer, "default(");
335 switch (OMP_CLAUSE_DEFAULT_KIND (clause))
337 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
339 case OMP_CLAUSE_DEFAULT_SHARED:
340 pp_string (buffer, "shared");
342 case OMP_CLAUSE_DEFAULT_NONE:
343 pp_string (buffer, "none");
345 case OMP_CLAUSE_DEFAULT_PRIVATE:
346 pp_string (buffer, "private");
351 pp_character (buffer, ')');
354 case OMP_CLAUSE_SCHEDULE:
355 pp_string (buffer, "schedule(");
356 switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
358 case OMP_CLAUSE_SCHEDULE_STATIC:
359 pp_string (buffer, "static");
361 case OMP_CLAUSE_SCHEDULE_DYNAMIC:
362 pp_string (buffer, "dynamic");
364 case OMP_CLAUSE_SCHEDULE_GUIDED:
365 pp_string (buffer, "guided");
367 case OMP_CLAUSE_SCHEDULE_RUNTIME:
368 pp_string (buffer, "runtime");
373 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
375 pp_character (buffer, ',');
376 dump_generic_node (buffer,
377 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
380 pp_character (buffer, ')');
384 /* Should never happen. */
385 dump_generic_node (buffer, clause, spc, flags, false);
391 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
392 dump_generic_node. */
395 dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
403 dump_omp_clause (buffer, clause, spc, flags);
404 clause = OMP_CLAUSE_CHAIN (clause);
412 /* Dump the set of decls SYMS. BUFFER, SPC and FLAGS are as in
413 dump_generic_node. */
416 dump_symbols (pretty_printer *buffer, bitmap syms, int flags)
422 pp_string (buffer, "NIL");
425 pp_string (buffer, " { ");
427 EXECUTE_IF_SET_IN_BITMAP (syms, 0, i, bi)
429 tree sym = referenced_var_lookup (i);
430 dump_generic_node (buffer, sym, 0, flags, false);
431 pp_string (buffer, " ");
434 pp_string (buffer, "}");
439 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
440 FLAGS specifies details to show in the dump (see TDF_* in tree-pass.h).
441 If IS_STMT is true, the object printed is considered to be a statement
442 and it is terminated by ';' if appropriate. */
445 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
453 if (node == NULL_TREE)
456 is_expr = EXPR_P (node) || GIMPLE_STMT_P (node);
458 /* We use has_stmt_ann because CALL_EXPR can be both an expression
459 and a statement, and we have no guarantee that it will have a
460 stmt_ann when it is used as an RHS expression. stmt_ann will assert
461 if you call it on something with a non-stmt annotation attached. */
462 if (TREE_CODE (node) != ERROR_MARK
463 && is_gimple_stmt (node)
464 && (flags & (TDF_VOPS|TDF_MEMSYMS))
465 && has_stmt_ann (node)
466 && TREE_CODE (node) != PHI_NODE)
467 dump_vops (buffer, node, spc, flags);
469 if (is_stmt && (flags & TDF_STMTADDR))
470 pp_printf (buffer, "<&%p> ", (void *)node);
472 if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
474 expanded_location xloc = expand_location (EXPR_LOCATION (node));
475 pp_character (buffer, '[');
478 pp_string (buffer, xloc.file);
479 pp_string (buffer, " : ");
481 pp_decimal_int (buffer, xloc.line);
482 pp_string (buffer, "] ");
485 switch (TREE_CODE (node))
488 pp_string (buffer, "<<< error >>>");
491 case IDENTIFIER_NODE:
492 pp_tree_identifier (buffer, node);
496 while (node && node != error_mark_node)
498 if (TREE_PURPOSE (node))
500 dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
503 dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
504 node = TREE_CHAIN (node);
505 if (node && TREE_CODE (node) == TREE_LIST)
507 pp_character (buffer, ',');
514 dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
519 if (TREE_VEC_LENGTH (node) > 0)
521 size_t len = TREE_VEC_LENGTH (node);
522 for (i = 0; i < len - 1; i++)
524 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
526 pp_character (buffer, ',');
529 dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
538 case FIXED_POINT_TYPE:
544 unsigned int quals = TYPE_QUALS (node);
545 enum tree_code_class class;
547 if (quals & TYPE_QUAL_CONST)
548 pp_string (buffer, "const ");
549 else if (quals & TYPE_QUAL_VOLATILE)
550 pp_string (buffer, "volatile ");
551 else if (quals & TYPE_QUAL_RESTRICT)
552 pp_string (buffer, "restrict ");
554 class = TREE_CODE_CLASS (TREE_CODE (node));
556 if (class == tcc_declaration)
558 if (DECL_NAME (node))
559 dump_decl_name (buffer, node, flags);
561 pp_string (buffer, "<unnamed type decl>");
563 else if (class == tcc_type)
565 if (TYPE_NAME (node))
567 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
568 pp_tree_identifier (buffer, TYPE_NAME (node));
569 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
570 && DECL_NAME (TYPE_NAME (node)))
571 dump_decl_name (buffer, TYPE_NAME (node), flags);
573 pp_string (buffer, "<unnamed type>");
575 else if (TREE_CODE (node) == VECTOR_TYPE)
577 pp_string (buffer, "vector ");
578 dump_generic_node (buffer, TREE_TYPE (node),
581 else if (TREE_CODE (node) == INTEGER_TYPE)
583 pp_string (buffer, (TYPE_UNSIGNED (node)
584 ? "<unnamed-unsigned:"
585 : "<unnamed-signed:"));
586 pp_decimal_int (buffer, TYPE_PRECISION (node));
587 pp_string (buffer, ">");
590 pp_string (buffer, "<unnamed type>");
597 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
599 if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
601 tree fnode = TREE_TYPE (node);
603 dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
605 pp_character (buffer, '(');
606 pp_string (buffer, str);
607 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
608 dump_decl_name (buffer, TYPE_NAME (node), flags);
610 pp_printf (buffer, "<T%x>", TYPE_UID (node));
612 pp_character (buffer, ')');
613 dump_function_declaration (buffer, fnode, spc, flags);
617 unsigned int quals = TYPE_QUALS (node);
619 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
621 pp_string (buffer, str);
623 if (quals & TYPE_QUAL_CONST)
624 pp_string (buffer, " const");
625 if (quals & TYPE_QUAL_VOLATILE)
626 pp_string (buffer, " volatile");
627 if (quals & TYPE_QUAL_RESTRICT)
628 pp_string (buffer, " restrict");
630 if (TYPE_REF_CAN_ALIAS_ALL (node))
631 pp_string (buffer, " {ref-all}");
640 dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
641 pp_string (buffer, "::");
646 const char *sep = "";
649 pp_string (buffer, "MEM[");
651 tmp = TMR_SYMBOL (node);
654 pp_string (buffer, sep);
656 pp_string (buffer, "symbol: ");
657 dump_generic_node (buffer, tmp, spc, flags, false);
659 tmp = TMR_BASE (node);
662 pp_string (buffer, sep);
664 pp_string (buffer, "base: ");
665 dump_generic_node (buffer, tmp, spc, flags, false);
667 tmp = TMR_INDEX (node);
670 pp_string (buffer, sep);
672 pp_string (buffer, "index: ");
673 dump_generic_node (buffer, tmp, spc, flags, false);
675 tmp = TMR_STEP (node);
678 pp_string (buffer, sep);
680 pp_string (buffer, "step: ");
681 dump_generic_node (buffer, tmp, spc, flags, false);
683 tmp = TMR_OFFSET (node);
686 pp_string (buffer, sep);
688 pp_string (buffer, "offset: ");
689 dump_generic_node (buffer, tmp, spc, flags, false);
691 pp_string (buffer, "]");
692 if (flags & TDF_DETAILS)
694 pp_string (buffer, "{");
695 dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,
697 pp_string (buffer, "}");
706 /* Print the innermost component type. */
707 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
708 tmp = TREE_TYPE (tmp))
710 dump_generic_node (buffer, tmp, spc, flags, false);
712 /* Print the dimensions. */
713 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
714 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
720 case QUAL_UNION_TYPE:
722 unsigned int quals = TYPE_QUALS (node);
724 if (quals & TYPE_QUAL_CONST)
725 pp_string (buffer, "const ");
726 if (quals & TYPE_QUAL_VOLATILE)
727 pp_string (buffer, "volatile ");
729 /* Print the name of the structure. */
730 if (TREE_CODE (node) == RECORD_TYPE)
731 pp_string (buffer, "struct ");
732 else if (TREE_CODE (node) == UNION_TYPE)
733 pp_string (buffer, "union ");
735 if (TYPE_NAME (node))
736 dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
738 print_struct_decl (buffer, node, spc, flags);
747 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
749 /* In the case of a pointer, one may want to divide by the
750 size of the pointed-to type. Unfortunately, this not
751 straightforward. The C front-end maps expressions
756 in such a way that the two INTEGER_CST nodes for "5" have
757 different values but identical types. In the latter
758 case, the 5 is multiplied by sizeof (int) in c-common.c
759 (pointer_int_sum) to convert it to a byte address, and
760 yet the type of the node is left unchanged. Argh. What
761 is consistent though is that the number value corresponds
762 to bytes (UNITS) offset.
764 NB: Neither of the following divisors can be trivially
765 used to recover the original literal:
767 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
768 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
769 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
770 pp_string (buffer, "B"); /* pseudo-unit */
772 else if (! host_integerp (node, 0))
775 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
776 HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);
778 if (tree_int_cst_sgn (val) < 0)
780 pp_character (buffer, '-');
784 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
786 sprintf (pp_buffer (buffer)->digit_buffer,
787 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
788 (unsigned HOST_WIDE_INT) high, low);
789 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
792 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
796 /* Code copied from print_node. */
799 if (TREE_OVERFLOW (node))
800 pp_string (buffer, " overflow");
802 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
803 d = TREE_REAL_CST (node);
804 if (REAL_VALUE_ISINF (d))
805 pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
806 else if (REAL_VALUE_ISNAN (d))
807 pp_string (buffer, " Nan");
811 real_to_decimal (string, &d, sizeof (string), 0, 1);
812 pp_string (buffer, string);
817 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
818 pp_string (buffer, "0x");
819 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
820 output_formatted_integer (buffer, "%02x", *p++);
829 fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
830 pp_string (buffer, string);
835 pp_string (buffer, "__complex__ (");
836 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
837 pp_string (buffer, ", ");
838 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
839 pp_string (buffer, ")");
843 pp_string (buffer, "\"");
844 pretty_print_string (buffer, TREE_STRING_POINTER (node));
845 pp_string (buffer, "\"");
851 pp_string (buffer, "{ ");
852 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
854 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
855 if (TREE_CHAIN (elt))
856 pp_string (buffer, ", ");
858 pp_string (buffer, " }");
867 dump_decl_name (buffer, node, flags);
871 if (DECL_NAME (node))
872 dump_decl_name (buffer, node, flags);
873 else if (LABEL_DECL_UID (node) != -1)
874 pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));
876 pp_printf (buffer, "<D.%u>", DECL_UID (node));
880 if (DECL_IS_BUILTIN (node))
882 /* Don't print the declaration of built-in types. */
885 if (DECL_NAME (node))
886 dump_decl_name (buffer, node, flags);
889 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
890 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
891 && TYPE_METHODS (TREE_TYPE (node)))
893 /* The type is a c++ class: all structures have at least
895 pp_string (buffer, "class ");
896 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
901 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
902 ? "union" : "struct "));
903 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
908 case SYMBOL_MEMORY_TAG:
909 case NAME_MEMORY_TAG:
914 case MEMORY_PARTITION_TAG:
915 dump_decl_name (buffer, node, flags);
919 pp_string (buffer, "<retval>");
923 op0 = TREE_OPERAND (node, 0);
925 if (TREE_CODE (op0) == INDIRECT_REF)
927 op0 = TREE_OPERAND (op0, 0);
930 if (op_prio (op0) < op_prio (node))
931 pp_character (buffer, '(');
932 dump_generic_node (buffer, op0, spc, flags, false);
933 if (op_prio (op0) < op_prio (node))
934 pp_character (buffer, ')');
935 pp_string (buffer, str);
936 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
938 if (TREE_CODE (op0) != VALUE_HANDLE)
940 op0 = component_ref_field_offset (node);
941 if (op0 && TREE_CODE (op0) != INTEGER_CST)
943 pp_string (buffer, "{off: ");
944 dump_generic_node (buffer, op0, spc, flags, false);
945 pp_character (buffer, '}');
951 pp_string (buffer, "BIT_FIELD_REF <");
952 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
953 pp_string (buffer, ", ");
954 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
955 pp_string (buffer, ", ");
956 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
957 pp_string (buffer, ">");
961 case ARRAY_RANGE_REF:
962 op0 = TREE_OPERAND (node, 0);
963 if (op_prio (op0) < op_prio (node))
964 pp_character (buffer, '(');
965 dump_generic_node (buffer, op0, spc, flags, false);
966 if (op_prio (op0) < op_prio (node))
967 pp_character (buffer, ')');
968 pp_character (buffer, '[');
969 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
970 if (TREE_CODE (node) == ARRAY_RANGE_REF)
971 pp_string (buffer, " ...");
972 pp_character (buffer, ']');
974 op0 = array_ref_low_bound (node);
975 op1 = array_ref_element_size (node);
977 if (!integer_zerop (op0)
978 || TREE_OPERAND (node, 2)
979 || TREE_OPERAND (node, 3))
981 pp_string (buffer, "{lb: ");
982 dump_generic_node (buffer, op0, spc, flags, false);
983 pp_string (buffer, " sz: ");
984 dump_generic_node (buffer, op1, spc, flags, false);
985 pp_character (buffer, '}');
991 unsigned HOST_WIDE_INT ix;
993 bool is_struct_init = FALSE;
994 pp_character (buffer, '{');
995 if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
996 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
997 is_struct_init = TRUE;
998 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
1000 if (field && is_struct_init)
1002 pp_character (buffer, '.');
1003 dump_generic_node (buffer, field, spc, flags, false);
1004 pp_string (buffer, "=");
1006 if (val && TREE_CODE (val) == ADDR_EXPR)
1007 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
1008 val = TREE_OPERAND (val, 0);
1009 if (val && TREE_CODE (val) == FUNCTION_DECL)
1010 dump_decl_name (buffer, val, flags);
1012 dump_generic_node (buffer, val, spc, flags, false);
1013 if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
1015 pp_character (buffer, ',');
1019 pp_character (buffer, '}');
1026 if (flags & TDF_SLIM)
1028 pp_string (buffer, "<COMPOUND_EXPR>");
1032 dump_generic_node (buffer, TREE_OPERAND (node, 0),
1033 spc, flags, !(flags & TDF_SLIM));
1034 if (flags & TDF_SLIM)
1035 newline_and_indent (buffer, spc);
1038 pp_character (buffer, ',');
1042 for (tp = &TREE_OPERAND (node, 1);
1043 TREE_CODE (*tp) == COMPOUND_EXPR;
1044 tp = &TREE_OPERAND (*tp, 1))
1046 dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
1047 spc, flags, !(flags & TDF_SLIM));
1048 if (flags & TDF_SLIM)
1049 newline_and_indent (buffer, spc);
1052 pp_character (buffer, ',');
1057 dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
1061 case STATEMENT_LIST:
1063 tree_stmt_iterator si;
1066 if (flags & TDF_SLIM)
1068 pp_string (buffer, "<STATEMENT_LIST>");
1072 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1075 newline_and_indent (buffer, spc);
1078 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
1084 case GIMPLE_MODIFY_STMT:
1086 dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 0), spc, flags,
1089 pp_character (buffer, '=');
1090 if (TREE_CODE (node) == GIMPLE_MODIFY_STMT
1091 && MOVE_NONTEMPORAL (node))
1092 pp_string (buffer, "{nt}");
1093 if (TREE_CODE (node) == GIMPLE_MODIFY_STMT)
1096 if ((ann = stmt_ann (node))
1097 && ann->has_volatile_ops)
1098 pp_string (buffer, "{v}");
1101 dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
1106 pp_string (buffer, "TARGET_EXPR <");
1107 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1108 pp_character (buffer, ',');
1110 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
1111 pp_character (buffer, '>');
1115 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1120 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1122 pp_string (buffer, "if (");
1123 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1124 pp_character (buffer, ')');
1125 /* The lowered cond_exprs should always be printed in full. */
1126 if (COND_EXPR_THEN (node)
1127 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1128 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1129 && COND_EXPR_ELSE (node)
1130 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1131 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1134 dump_generic_node (buffer, COND_EXPR_THEN (node),
1136 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1138 pp_string (buffer, " else ");
1139 dump_generic_node (buffer, COND_EXPR_ELSE (node),
1143 else if (!(flags & TDF_SLIM))
1145 /* Output COND_EXPR_THEN. */
1146 if (COND_EXPR_THEN (node))
1148 newline_and_indent (buffer, spc+2);
1149 pp_character (buffer, '{');
1150 newline_and_indent (buffer, spc+4);
1151 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1153 newline_and_indent (buffer, spc+2);
1154 pp_character (buffer, '}');
1157 /* Output COND_EXPR_ELSE. */
1158 if (COND_EXPR_ELSE (node)
1159 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1161 newline_and_indent (buffer, spc);
1162 pp_string (buffer, "else");
1163 newline_and_indent (buffer, spc+2);
1164 pp_character (buffer, '{');
1165 newline_and_indent (buffer, spc+4);
1166 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1168 newline_and_indent (buffer, spc+2);
1169 pp_character (buffer, '}');
1176 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1178 pp_character (buffer, '?');
1180 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1182 pp_character (buffer, ':');
1184 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1189 pp_character (buffer, '{');
1190 if (!(flags & TDF_SLIM))
1192 if (BIND_EXPR_VARS (node))
1194 pp_newline (buffer);
1196 for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
1198 print_declaration (buffer, op0, spc+2, flags);
1199 pp_newline (buffer);
1203 newline_and_indent (buffer, spc+2);
1204 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1205 newline_and_indent (buffer, spc);
1206 pp_character (buffer, '}');
1212 print_call_name (buffer, node);
1214 /* Print parameters. */
1216 pp_character (buffer, '(');
1219 call_expr_arg_iterator iter;
1220 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
1222 dump_generic_node (buffer, arg, spc, flags, false);
1223 if (more_call_expr_args_p (&iter))
1225 pp_character (buffer, ',');
1230 if (CALL_EXPR_VA_ARG_PACK (node))
1232 if (call_expr_nargs (node) > 0)
1234 pp_character (buffer, ',');
1237 pp_string (buffer, "__builtin_va_arg_pack ()");
1239 pp_character (buffer, ')');
1241 op1 = CALL_EXPR_STATIC_CHAIN (node);
1244 pp_string (buffer, " [static-chain: ");
1245 dump_generic_node (buffer, op1, spc, flags, false);
1246 pp_character (buffer, ']');
1249 if (CALL_EXPR_RETURN_SLOT_OPT (node))
1250 pp_string (buffer, " [return slot optimization]");
1251 if (CALL_EXPR_TAILCALL (node))
1252 pp_string (buffer, " [tail call]");
1255 case WITH_CLEANUP_EXPR:
1259 case CLEANUP_POINT_EXPR:
1260 pp_string (buffer, "<<cleanup_point ");
1261 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1262 pp_string (buffer, ">>");
1265 case PLACEHOLDER_EXPR:
1266 pp_string (buffer, "<PLACEHOLDER_EXPR ");
1267 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1268 pp_character (buffer, '>');
1271 /* Binary arithmetic and logic expressions. */
1272 case WIDEN_SUM_EXPR:
1273 case WIDEN_MULT_EXPR:
1276 case POINTER_PLUS_EXPR:
1278 case TRUNC_DIV_EXPR:
1280 case FLOOR_DIV_EXPR:
1281 case ROUND_DIV_EXPR:
1282 case TRUNC_MOD_EXPR:
1284 case FLOOR_MOD_EXPR:
1285 case ROUND_MOD_EXPR:
1287 case EXACT_DIV_EXPR:
1292 case VEC_LSHIFT_EXPR:
1293 case VEC_RSHIFT_EXPR:
1297 case TRUTH_ANDIF_EXPR:
1298 case TRUTH_ORIF_EXPR:
1299 case TRUTH_AND_EXPR:
1301 case TRUTH_XOR_EXPR:
1315 case UNORDERED_EXPR:
1317 const char *op = op_symbol (node);
1318 op0 = TREE_OPERAND (node, 0);
1319 op1 = TREE_OPERAND (node, 1);
1321 /* When the operands are expressions with less priority,
1322 keep semantics of the tree representation. */
1323 if (op_prio (op0) <= op_prio (node))
1325 pp_character (buffer, '(');
1326 dump_generic_node (buffer, op0, spc, flags, false);
1327 pp_character (buffer, ')');
1330 dump_generic_node (buffer, op0, spc, flags, false);
1333 pp_string (buffer, op);
1336 /* When the operands are expressions with less priority,
1337 keep semantics of the tree representation. */
1338 if (op_prio (op1) <= op_prio (node))
1340 pp_character (buffer, '(');
1341 dump_generic_node (buffer, op1, spc, flags, false);
1342 pp_character (buffer, ')');
1345 dump_generic_node (buffer, op1, spc, flags, false);
1349 /* Unary arithmetic and logic expressions. */
1352 case TRUTH_NOT_EXPR:
1354 case PREDECREMENT_EXPR:
1355 case PREINCREMENT_EXPR:
1356 case ALIGN_INDIRECT_REF:
1357 case MISALIGNED_INDIRECT_REF:
1359 if (TREE_CODE (node) == ADDR_EXPR
1360 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1361 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1362 ; /* Do not output '&' for strings and function pointers. */
1364 pp_string (buffer, op_symbol (node));
1366 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1368 pp_character (buffer, '(');
1369 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1370 pp_character (buffer, ')');
1373 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1375 if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1377 pp_string (buffer, "{misalignment: ");
1378 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1379 pp_character (buffer, '}');
1383 case POSTDECREMENT_EXPR:
1384 case POSTINCREMENT_EXPR:
1385 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1387 pp_character (buffer, '(');
1388 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1389 pp_character (buffer, ')');
1392 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1393 pp_string (buffer, op_symbol (node));
1397 pp_string (buffer, "MIN_EXPR <");
1398 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1399 pp_string (buffer, ", ");
1400 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1401 pp_character (buffer, '>');
1405 pp_string (buffer, "MAX_EXPR <");
1406 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1407 pp_string (buffer, ", ");
1408 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1409 pp_character (buffer, '>');
1413 pp_string (buffer, "ABS_EXPR <");
1414 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1415 pp_character (buffer, '>');
1422 case FIXED_CONVERT_EXPR:
1423 case FIX_TRUNC_EXPR:
1426 type = TREE_TYPE (node);
1427 op0 = TREE_OPERAND (node, 0);
1428 if (type != TREE_TYPE (op0))
1430 pp_character (buffer, '(');
1431 dump_generic_node (buffer, type, spc, flags, false);
1432 pp_string (buffer, ") ");
1434 if (op_prio (op0) < op_prio (node))
1435 pp_character (buffer, '(');
1436 dump_generic_node (buffer, op0, spc, flags, false);
1437 if (op_prio (op0) < op_prio (node))
1438 pp_character (buffer, ')');
1441 case VIEW_CONVERT_EXPR:
1442 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1443 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1444 pp_string (buffer, ">(");
1445 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1446 pp_character (buffer, ')');
1450 pp_string (buffer, "((");
1451 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1452 pp_string (buffer, "))");
1455 case NON_LVALUE_EXPR:
1456 pp_string (buffer, "NON_LVALUE_EXPR <");
1457 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1458 pp_character (buffer, '>');
1462 pp_string (buffer, "SAVE_EXPR <");
1463 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1464 pp_character (buffer, '>');
1468 pp_string (buffer, "COMPLEX_EXPR <");
1469 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1470 pp_string (buffer, ", ");
1471 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1472 pp_string (buffer, ">");
1476 pp_string (buffer, "CONJ_EXPR <");
1477 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1478 pp_string (buffer, ">");
1482 pp_string (buffer, "REALPART_EXPR <");
1483 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1484 pp_string (buffer, ">");
1488 pp_string (buffer, "IMAGPART_EXPR <");
1489 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1490 pp_string (buffer, ">");
1494 pp_string (buffer, "VA_ARG_EXPR <");
1495 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1496 pp_string (buffer, ">");
1499 case TRY_FINALLY_EXPR:
1500 case TRY_CATCH_EXPR:
1501 pp_string (buffer, "try");
1502 newline_and_indent (buffer, spc+2);
1503 pp_string (buffer, "{");
1504 newline_and_indent (buffer, spc+4);
1505 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1506 newline_and_indent (buffer, spc+2);
1507 pp_string (buffer, "}");
1508 newline_and_indent (buffer, spc);
1510 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1511 newline_and_indent (buffer, spc+2);
1512 pp_string (buffer, "{");
1513 newline_and_indent (buffer, spc+4);
1514 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1515 newline_and_indent (buffer, spc+2);
1516 pp_string (buffer, "}");
1521 pp_string (buffer, "catch (");
1522 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1523 pp_string (buffer, ")");
1524 newline_and_indent (buffer, spc+2);
1525 pp_string (buffer, "{");
1526 newline_and_indent (buffer, spc+4);
1527 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1528 newline_and_indent (buffer, spc+2);
1529 pp_string (buffer, "}");
1533 case EH_FILTER_EXPR:
1534 pp_string (buffer, "<<<eh_filter (");
1535 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1536 pp_string (buffer, ")>>>");
1537 newline_and_indent (buffer, spc+2);
1538 pp_string (buffer, "{");
1539 newline_and_indent (buffer, spc+4);
1540 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1541 newline_and_indent (buffer, spc+2);
1542 pp_string (buffer, "}");
1546 case CHANGE_DYNAMIC_TYPE_EXPR:
1547 pp_string (buffer, "<<<change_dynamic_type (");
1548 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_NEW_TYPE (node), spc + 2,
1550 pp_string (buffer, ") ");
1551 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_LOCATION (node), spc + 2,
1553 pp_string (buffer, ")>>>");
1558 op0 = TREE_OPERAND (node, 0);
1559 /* If this is for break or continue, don't bother printing it. */
1560 if (DECL_NAME (op0))
1562 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1563 if (strcmp (name, "break") == 0
1564 || strcmp (name, "continue") == 0)
1567 dump_generic_node (buffer, op0, spc, flags, false);
1568 pp_character (buffer, ':');
1569 if (DECL_NONLOCAL (op0))
1570 pp_string (buffer, " [non-local]");
1574 pp_string (buffer, "<<<exception object>>>");
1578 pp_string (buffer, "<<<filter object>>>");
1582 pp_string (buffer, "while (1)");
1583 if (!(flags & TDF_SLIM))
1585 newline_and_indent (buffer, spc+2);
1586 pp_character (buffer, '{');
1587 newline_and_indent (buffer, spc+4);
1588 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1589 newline_and_indent (buffer, spc+2);
1590 pp_character (buffer, '}');
1596 pp_string (buffer, "// predicted ");
1597 if (PREDICT_EXPR_OUTCOME (node))
1598 pp_string (buffer, "likely by ");
1600 pp_string (buffer, "unlikely by ");
1601 pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
1602 pp_string (buffer, " predictor.");
1606 pp_string (buffer, "return");
1607 op0 = TREE_OPERAND (node, 0);
1611 if (TREE_CODE (op0) == MODIFY_EXPR
1612 || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
1613 dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
1616 dump_generic_node (buffer, op0, spc, flags, false);
1621 pp_string (buffer, "if (");
1622 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1623 pp_string (buffer, ") break");
1627 pp_string (buffer, "switch (");
1628 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1629 pp_character (buffer, ')');
1630 if (!(flags & TDF_SLIM))
1632 newline_and_indent (buffer, spc+2);
1633 pp_character (buffer, '{');
1634 if (SWITCH_BODY (node))
1636 newline_and_indent (buffer, spc+4);
1637 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1642 tree vec = SWITCH_LABELS (node);
1643 size_t i, n = TREE_VEC_LENGTH (vec);
1644 for (i = 0; i < n; ++i)
1646 tree elt = TREE_VEC_ELT (vec, i);
1647 newline_and_indent (buffer, spc+4);
1650 dump_generic_node (buffer, elt, spc+4, flags, false);
1651 pp_string (buffer, " goto ");
1652 dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1654 pp_semicolon (buffer);
1657 pp_string (buffer, "case ???: goto ???;");
1660 newline_and_indent (buffer, spc+2);
1661 pp_character (buffer, '}');
1667 op0 = GOTO_DESTINATION (node);
1668 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1670 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1671 if (strcmp (name, "break") == 0
1672 || strcmp (name, "continue") == 0)
1674 pp_string (buffer, name);
1678 pp_string (buffer, "goto ");
1679 dump_generic_node (buffer, op0, spc, flags, false);
1683 pp_string (buffer, "resx ");
1684 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1688 pp_string (buffer, "__asm__");
1689 if (ASM_VOLATILE_P (node))
1690 pp_string (buffer, " __volatile__");
1691 pp_character (buffer, '(');
1692 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1693 pp_character (buffer, ':');
1694 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1695 pp_character (buffer, ':');
1696 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1697 if (ASM_CLOBBERS (node))
1699 pp_character (buffer, ':');
1700 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1702 pp_string (buffer, ")");
1705 case CASE_LABEL_EXPR:
1706 if (CASE_LOW (node) && CASE_HIGH (node))
1708 pp_string (buffer, "case ");
1709 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1710 pp_string (buffer, " ... ");
1711 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1713 else if (CASE_LOW (node))
1715 pp_string (buffer, "case ");
1716 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1719 pp_string (buffer, "default ");
1720 pp_character (buffer, ':');
1724 pp_string (buffer, "OBJ_TYPE_REF(");
1725 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1726 pp_character (buffer, ';');
1727 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1728 pp_character (buffer, '-');
1729 pp_character (buffer, '>');
1730 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1731 pp_character (buffer, ')');
1738 dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1739 pp_string (buffer, " = PHI <");
1740 for (i = 0; i < PHI_NUM_ARGS (node); i++)
1742 dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1743 pp_string (buffer, "(");
1744 pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1745 pp_string (buffer, ")");
1746 if (i < PHI_NUM_ARGS (node) - 1)
1747 pp_string (buffer, ", ");
1749 pp_string (buffer, ">");
1751 if (stmt_references_memory_p (node) && (flags & TDF_MEMSYMS))
1752 dump_symbols (buffer, STORED_SYMS (node), flags);
1757 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1758 pp_string (buffer, "_");
1759 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1760 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1761 pp_string (buffer, "(ab)");
1762 else if (SSA_NAME_IS_DEFAULT_DEF (node))
1763 pp_string (buffer, "(D)");
1766 case WITH_SIZE_EXPR:
1767 pp_string (buffer, "WITH_SIZE_EXPR <");
1768 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1769 pp_string (buffer, ", ");
1770 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1771 pp_string (buffer, ">");
1775 pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1779 pp_string (buffer, "ASSERT_EXPR <");
1780 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1781 pp_string (buffer, ", ");
1782 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1783 pp_string (buffer, ">");
1787 pp_string (buffer, "scev_known");
1790 case SCEV_NOT_KNOWN:
1791 pp_string (buffer, "scev_not_known");
1794 case POLYNOMIAL_CHREC:
1795 pp_string (buffer, "{");
1796 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1797 pp_string (buffer, ", +, ");
1798 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1799 pp_string (buffer, "}_");
1800 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1804 case REALIGN_LOAD_EXPR:
1805 pp_string (buffer, "REALIGN_LOAD <");
1806 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1807 pp_string (buffer, ", ");
1808 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1809 pp_string (buffer, ", ");
1810 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1811 pp_string (buffer, ">");
1815 pp_string (buffer, " VEC_COND_EXPR < ");
1816 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1817 pp_string (buffer, " , ");
1818 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1819 pp_string (buffer, " , ");
1820 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1821 pp_string (buffer, " > ");
1825 pp_string (buffer, " DOT_PROD_EXPR < ");
1826 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1827 pp_string (buffer, ", ");
1828 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1829 pp_string (buffer, ", ");
1830 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1831 pp_string (buffer, " > ");
1835 pp_string (buffer, "#pragma omp parallel");
1836 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
1837 if (OMP_PARALLEL_FN (node))
1839 pp_string (buffer, " [child fn: ");
1840 dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);
1842 pp_string (buffer, " (");
1844 if (OMP_PARALLEL_DATA_ARG (node))
1845 dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,
1848 pp_string (buffer, "???");
1850 pp_string (buffer, ")]");
1854 if (!(flags & TDF_SLIM) && OMP_BODY (node))
1856 newline_and_indent (buffer, spc + 2);
1857 pp_character (buffer, '{');
1858 newline_and_indent (buffer, spc + 4);
1859 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
1860 newline_and_indent (buffer, spc + 2);
1861 pp_character (buffer, '}');
1867 pp_string (buffer, "#pragma omp for");
1868 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
1870 if (!(flags & TDF_SLIM))
1872 if (OMP_FOR_PRE_BODY (node))
1874 newline_and_indent (buffer, spc + 2);
1875 pp_character (buffer, '{');
1877 newline_and_indent (buffer, spc);
1878 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
1881 newline_and_indent (buffer, spc);
1882 pp_string (buffer, "for (");
1883 dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);
1884 pp_string (buffer, "; ");
1885 dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);
1886 pp_string (buffer, "; ");
1887 dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);
1888 pp_string (buffer, ")");
1889 if (OMP_FOR_BODY (node))
1891 newline_and_indent (buffer, spc + 2);
1892 pp_character (buffer, '{');
1893 newline_and_indent (buffer, spc + 4);
1894 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
1896 newline_and_indent (buffer, spc + 2);
1897 pp_character (buffer, '}');
1899 if (OMP_FOR_PRE_BODY (node))
1902 newline_and_indent (buffer, spc + 2);
1903 pp_character (buffer, '}');
1910 pp_string (buffer, "#pragma omp sections");
1911 if (OMP_SECTIONS_CONTROL (node))
1913 pp_string (buffer, " <");
1914 dump_generic_node (buffer, OMP_SECTIONS_CONTROL (node), spc,
1916 pp_string (buffer, ">");
1918 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
1921 case OMP_SECTIONS_SWITCH:
1922 pp_string (buffer, "OMP_SECTIONS_SWITCH");
1927 pp_string (buffer, "#pragma omp section");
1931 pp_string (buffer, "#pragma omp master");
1935 pp_string (buffer, "#pragma omp ordered");
1939 pp_string (buffer, "#pragma omp critical");
1940 if (OMP_CRITICAL_NAME (node))
1943 pp_character (buffer, '(');
1944 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
1946 pp_character (buffer, ')');
1951 pp_string (buffer, "#pragma omp atomic");
1952 newline_and_indent (buffer, spc + 2);
1953 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1955 pp_character (buffer, '=');
1957 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1960 case OMP_ATOMIC_LOAD:
1961 pp_string (buffer, "#pragma omp atomic_load");
1962 newline_and_indent (buffer, spc + 2);
1963 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1965 pp_character (buffer, '=');
1967 pp_character (buffer, '*');
1968 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1971 case OMP_ATOMIC_STORE:
1972 pp_string (buffer, "#pragma omp atomic_store (");
1973 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1974 pp_character (buffer, ')');
1978 pp_string (buffer, "#pragma omp single");
1979 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
1983 pp_string (buffer, "OMP_RETURN");
1984 if (OMP_RETURN_NOWAIT (node))
1985 pp_string (buffer, " [nowait]");
1990 pp_string (buffer, "OMP_CONTINUE <");
1991 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1992 pp_string (buffer, " <- ");
1993 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1994 pp_string (buffer, ">");
1999 dump_omp_clause (buffer, node, spc, flags);
2003 case REDUC_MAX_EXPR:
2004 pp_string (buffer, " REDUC_MAX_EXPR < ");
2005 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2006 pp_string (buffer, " > ");
2009 case REDUC_MIN_EXPR:
2010 pp_string (buffer, " REDUC_MIN_EXPR < ");
2011 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2012 pp_string (buffer, " > ");
2015 case REDUC_PLUS_EXPR:
2016 pp_string (buffer, " REDUC_PLUS_EXPR < ");
2017 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2018 pp_string (buffer, " > ");
2021 case VEC_WIDEN_MULT_HI_EXPR:
2022 pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
2023 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2024 pp_string (buffer, ", ");
2025 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2026 pp_string (buffer, " > ");
2029 case VEC_WIDEN_MULT_LO_EXPR:
2030 pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
2031 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2032 pp_string (buffer, ", ");
2033 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2034 pp_string (buffer, " > ");
2037 case VEC_UNPACK_HI_EXPR:
2038 pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
2039 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2040 pp_string (buffer, " > ");
2043 case VEC_UNPACK_LO_EXPR:
2044 pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
2045 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2046 pp_string (buffer, " > ");
2049 case VEC_UNPACK_FLOAT_HI_EXPR:
2050 pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2051 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2052 pp_string (buffer, " > ");
2055 case VEC_UNPACK_FLOAT_LO_EXPR:
2056 pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2057 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2058 pp_string (buffer, " > ");
2061 case VEC_PACK_TRUNC_EXPR:
2062 pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
2063 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2064 pp_string (buffer, ", ");
2065 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2066 pp_string (buffer, " > ");
2069 case VEC_PACK_SAT_EXPR:
2070 pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
2071 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2072 pp_string (buffer, ", ");
2073 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2074 pp_string (buffer, " > ");
2077 case VEC_PACK_FIX_TRUNC_EXPR:
2078 pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");
2079 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2080 pp_string (buffer, ", ");
2081 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2082 pp_string (buffer, " > ");
2088 pp_string (buffer, "BLOCK");
2090 if (BLOCK_ABSTRACT (node))
2091 pp_string (buffer, " [abstract]");
2093 if (TREE_ASM_WRITTEN (node))
2094 pp_string (buffer, " [written]");
2096 newline_and_indent (buffer, spc + 2);
2098 if (BLOCK_SUPERCONTEXT (node))
2100 pp_string (buffer, "SUPERCONTEXT: ");
2101 if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
2102 pp_printf (buffer, "BLOCK %p",
2103 (void *)BLOCK_SUPERCONTEXT (node));
2105 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
2107 newline_and_indent (buffer, spc + 2);
2110 if (BLOCK_SUBBLOCKS (node))
2112 pp_string (buffer, "SUBBLOCKS: ");
2113 for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
2114 pp_printf (buffer, "%p ", (void *)t);
2115 newline_and_indent (buffer, spc + 2);
2118 if (BLOCK_VARS (node))
2120 pp_string (buffer, "VARS: ");
2121 for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
2123 dump_generic_node (buffer, t, 0, flags, false);
2124 pp_string (buffer, " ");
2126 newline_and_indent (buffer, spc + 2);
2129 if (BLOCK_ABSTRACT_ORIGIN (node))
2131 pp_string (buffer, "ABSTRACT_ORIGIN: ");
2132 if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
2133 pp_printf (buffer, "BLOCK %p",
2134 (void *)BLOCK_ABSTRACT_ORIGIN (node));
2136 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
2138 newline_and_indent (buffer, spc + 2);
2143 case VEC_EXTRACT_EVEN_EXPR:
2144 pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
2145 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2146 pp_string (buffer, ", ");
2147 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2148 pp_string (buffer, " > ");
2151 case VEC_EXTRACT_ODD_EXPR:
2152 pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
2153 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2154 pp_string (buffer, ", ");
2155 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2156 pp_string (buffer, " > ");
2159 case VEC_INTERLEAVE_HIGH_EXPR:
2160 pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
2161 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2162 pp_string (buffer, ", ");
2163 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2164 pp_string (buffer, " > ");
2167 case VEC_INTERLEAVE_LOW_EXPR:
2168 pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
2169 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2170 pp_string (buffer, ", ");
2171 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2172 pp_string (buffer, " > ");
2179 if (is_stmt && is_expr)
2180 pp_semicolon (buffer);
2182 /* If we're building a diagnostic, the formatted text will be written
2183 into BUFFER's stream by the caller; otherwise, write it now. */
2184 if (!(flags & TDF_DIAGNOSTIC))
2185 pp_write_text_to_stream (buffer);
2190 /* Print the declaration of a variable. */
2193 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2197 if (TREE_CODE (t) == TYPE_DECL)
2198 pp_string (buffer, "typedef ");
2200 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2201 pp_string (buffer, "register ");
2203 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2204 pp_string (buffer, "extern ");
2205 else if (TREE_STATIC (t))
2206 pp_string (buffer, "static ");
2208 /* Print the type and name. */
2209 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2213 /* Print array's type. */
2214 tmp = TREE_TYPE (t);
2215 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2216 tmp = TREE_TYPE (tmp);
2217 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2219 /* Print variable's name. */
2221 dump_generic_node (buffer, t, spc, flags, false);
2223 /* Print the dimensions. */
2224 tmp = TREE_TYPE (t);
2225 while (TREE_CODE (tmp) == ARRAY_TYPE)
2227 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
2228 tmp = TREE_TYPE (tmp);
2231 else if (TREE_CODE (t) == FUNCTION_DECL)
2233 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2235 dump_decl_name (buffer, t, flags);
2236 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2240 /* Print type declaration. */
2241 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2243 /* Print variable's name. */
2245 dump_generic_node (buffer, t, spc, flags, false);
2248 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2250 pp_string (buffer, " __asm__ ");
2251 pp_character (buffer, '(');
2252 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2253 pp_character (buffer, ')');
2256 /* The initial value of a function serves to determine wether the function
2257 is declared or defined. So the following does not apply to function
2259 if (TREE_CODE (t) != FUNCTION_DECL)
2261 /* Print the initial value. */
2262 if (DECL_INITIAL (t))
2265 pp_character (buffer, '=');
2267 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2271 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2273 pp_string (buffer, " [value-expr: ");
2274 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2275 pp_character (buffer, ']');
2278 pp_character (buffer, ';');
2282 /* Prints a structure: name, fields, and methods.
2283 FIXME: Still incomplete. */
2286 print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
2288 /* Print the name of the structure. */
2289 if (TYPE_NAME (node))
2292 if (TREE_CODE (node) == RECORD_TYPE)
2293 pp_string (buffer, "struct ");
2294 else if ((TREE_CODE (node) == UNION_TYPE
2295 || TREE_CODE (node) == QUAL_UNION_TYPE))
2296 pp_string (buffer, "union ");
2298 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2301 /* Print the contents of the structure. */
2302 pp_newline (buffer);
2304 pp_character (buffer, '{');
2305 pp_newline (buffer);
2307 /* Print the fields of the structure. */
2310 tmp = TYPE_FIELDS (node);
2313 /* Avoid to print recursively the structure. */
2314 /* FIXME : Not implemented correctly...,
2315 what about the case when we have a cycle in the contain graph? ...
2316 Maybe this could be solved by looking at the scope in which the
2317 structure was declared. */
2318 if (TREE_TYPE (tmp) != node
2319 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
2320 && TREE_TYPE (TREE_TYPE (tmp)) != node))
2322 print_declaration (buffer, tmp, spc+2, flags);
2323 pp_newline (buffer);
2325 tmp = TREE_CHAIN (tmp);
2329 pp_character (buffer, '}');
2332 /* Return the priority of the operator OP.
2334 From lowest to highest precedence with either left-to-right (L-R)
2335 or right-to-left (R-L) associativity]:
2338 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2350 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2351 15 [L-R] fn() [] -> .
2353 unary +, - and * have higher precedence than the corresponding binary
2357 op_prio (const_tree op)
2362 switch (TREE_CODE (op))
2370 case GIMPLE_MODIFY_STMT:
2378 case TRUTH_ORIF_EXPR:
2381 case TRUTH_AND_EXPR:
2382 case TRUTH_ANDIF_EXPR:
2389 case TRUTH_XOR_EXPR:
2406 case UNORDERED_EXPR:
2419 case WIDEN_SUM_EXPR:
2421 case POINTER_PLUS_EXPR:
2425 case VEC_WIDEN_MULT_HI_EXPR:
2426 case VEC_WIDEN_MULT_LO_EXPR:
2427 case WIDEN_MULT_EXPR:
2430 case TRUNC_DIV_EXPR:
2432 case FLOOR_DIV_EXPR:
2433 case ROUND_DIV_EXPR:
2435 case EXACT_DIV_EXPR:
2436 case TRUNC_MOD_EXPR:
2438 case FLOOR_MOD_EXPR:
2439 case ROUND_MOD_EXPR:
2442 case TRUTH_NOT_EXPR:
2444 case POSTINCREMENT_EXPR:
2445 case POSTDECREMENT_EXPR:
2446 case PREINCREMENT_EXPR:
2447 case PREDECREMENT_EXPR:
2449 case ALIGN_INDIRECT_REF:
2450 case MISALIGNED_INDIRECT_REF:
2455 case FIX_TRUNC_EXPR:
2461 case ARRAY_RANGE_REF:
2465 /* Special expressions. */
2471 case REDUC_MAX_EXPR:
2472 case REDUC_MIN_EXPR:
2473 case REDUC_PLUS_EXPR:
2474 case VEC_LSHIFT_EXPR:
2475 case VEC_RSHIFT_EXPR:
2476 case VEC_UNPACK_HI_EXPR:
2477 case VEC_UNPACK_LO_EXPR:
2478 case VEC_UNPACK_FLOAT_HI_EXPR:
2479 case VEC_UNPACK_FLOAT_LO_EXPR:
2480 case VEC_PACK_TRUNC_EXPR:
2481 case VEC_PACK_SAT_EXPR:
2485 case NON_LVALUE_EXPR:
2486 return op_prio (TREE_OPERAND (op, 0));
2489 /* Return an arbitrarily high precedence to avoid surrounding single
2490 VAR_DECLs in ()s. */
2496 /* Return the symbol associated with operator CODE. */
2499 op_symbol_code (enum tree_code code)
2504 case GIMPLE_MODIFY_STMT:
2508 case TRUTH_ORIF_EXPR:
2511 case TRUTH_AND_EXPR:
2512 case TRUTH_ANDIF_EXPR:
2518 case TRUTH_XOR_EXPR:
2528 case UNORDERED_EXPR:
2574 case VEC_LSHIFT_EXPR:
2577 case VEC_RSHIFT_EXPR:
2580 case POINTER_PLUS_EXPR:
2586 case REDUC_PLUS_EXPR:
2589 case WIDEN_SUM_EXPR:
2592 case WIDEN_MULT_EXPR:
2602 case TRUTH_NOT_EXPR:
2609 case ALIGN_INDIRECT_REF:
2612 case MISALIGNED_INDIRECT_REF:
2615 case TRUNC_DIV_EXPR:
2622 case FLOOR_DIV_EXPR:
2625 case ROUND_DIV_EXPR:
2628 case EXACT_DIV_EXPR:
2631 case TRUNC_MOD_EXPR:
2637 case FLOOR_MOD_EXPR:
2640 case ROUND_MOD_EXPR:
2643 case PREDECREMENT_EXPR:
2646 case PREINCREMENT_EXPR:
2649 case POSTDECREMENT_EXPR:
2652 case POSTINCREMENT_EXPR:
2662 return "<<< ??? >>>";
2666 /* Return the symbol associated with operator OP. */
2669 op_symbol (const_tree op)
2671 return op_symbol_code (TREE_CODE (op));
2674 /* Prints the name of a CALL_EXPR. */
2677 print_call_name (pretty_printer *buffer, const_tree node)
2681 gcc_assert (TREE_CODE (node) == CALL_EXPR);
2683 op0 = CALL_EXPR_FN (node);
2685 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2686 op0 = TREE_OPERAND (op0, 0);
2688 switch (TREE_CODE (op0))
2692 dump_function_name (buffer, op0);
2698 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2702 pp_string (buffer, "(");
2703 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2704 pp_string (buffer, ") ? ");
2705 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
2706 pp_string (buffer, " : ");
2707 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
2711 /* The function is a pointer contained in a structure. */
2712 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
2713 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2714 dump_function_name (buffer, TREE_OPERAND (op0, 1));
2716 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2718 We can have several levels of structures and a function
2719 pointer inside. This is not implemented yet... */
2724 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2725 dump_function_name (buffer, TREE_OPERAND (op0, 0));
2727 dump_generic_node (buffer, op0, 0, 0, false);
2732 dump_generic_node (buffer, op0, 0, 0, false);
2740 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2743 pretty_print_string (pretty_printer *buffer, const char *str)
2753 pp_string (buffer, "\\b");
2757 pp_string (buffer, "\\f");
2761 pp_string (buffer, "\\n");
2765 pp_string (buffer, "\\r");
2769 pp_string (buffer, "\\t");
2773 pp_string (buffer, "\\v");
2777 pp_string (buffer, "\\\\");
2781 pp_string (buffer, "\\\"");
2785 pp_string (buffer, "\\'");
2788 /* No need to handle \0; the loop terminates on \0. */
2791 pp_string (buffer, "\\1");
2795 pp_string (buffer, "\\2");
2799 pp_string (buffer, "\\3");
2803 pp_string (buffer, "\\4");
2807 pp_string (buffer, "\\5");
2811 pp_string (buffer, "\\6");
2815 pp_string (buffer, "\\7");
2819 pp_character (buffer, str[0]);
2827 maybe_init_pretty_print (FILE *file)
2831 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2832 pp_needs_newline (&buffer) = true;
2836 buffer.buffer->stream = file;
2840 newline_and_indent (pretty_printer *buffer, int spc)
2842 pp_newline (buffer);
2848 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2850 struct voptype_d *vdefs;
2851 struct voptype_d *vuses;
2854 if (!ssa_operands_active () || !stmt_references_memory_p (stmt))
2857 /* Even if the statement doesn't have virtual operators yet, it may
2858 contain symbol information (this happens before aliases have been
2860 if ((flags & TDF_MEMSYMS)
2861 && VUSE_OPS (stmt) == NULL
2862 && VDEF_OPS (stmt) == NULL)
2864 if (LOADED_SYMS (stmt))
2866 pp_string (buffer, "# LOADS: ");
2867 dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2868 newline_and_indent (buffer, spc);
2871 if (STORED_SYMS (stmt))
2873 pp_string (buffer, "# STORES: ");
2874 dump_symbols (buffer, STORED_SYMS (stmt), flags);
2875 newline_and_indent (buffer, spc);
2881 vuses = VUSE_OPS (stmt);
2884 pp_string (buffer, "# VUSE <");
2886 n = VUSE_NUM (vuses);
2887 for (i = 0; i < n; i++)
2889 dump_generic_node (buffer, VUSE_OP (vuses, i), spc + 2, flags, false);
2891 pp_string (buffer, ", ");
2894 pp_string (buffer, ">");
2896 if (flags & TDF_MEMSYMS)
2897 dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2899 newline_and_indent (buffer, spc);
2900 vuses = vuses->next;
2903 vdefs = VDEF_OPS (stmt);
2906 pp_string (buffer, "# ");
2907 dump_generic_node (buffer, VDEF_RESULT (vdefs), spc + 2, flags, false);
2908 pp_string (buffer, " = VDEF <");
2910 n = VDEF_NUM (vdefs);
2911 for (i = 0; i < n; i++)
2913 dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, 0);
2915 pp_string (buffer, ", ");
2918 pp_string (buffer, ">");
2920 if ((flags & TDF_MEMSYMS) && vdefs->next == NULL)
2921 dump_symbols (buffer, STORED_SYMS (stmt), flags);
2923 newline_and_indent (buffer, spc);
2924 vdefs = vdefs->next;
2929 /* Dumps basic block BB to FILE with details described by FLAGS and
2930 indented by INDENT spaces. */
2933 dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2935 maybe_init_pretty_print (file);
2936 dump_generic_bb_buff (&buffer, bb, indent, flags);
2940 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2941 spaces and details described by flags. */
2944 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2950 if (flags & TDF_BLOCKS)
2953 pp_string (buffer, "# BLOCK ");
2954 pp_decimal_int (buffer, bb->index);
2957 pp_string (buffer, " freq:");
2958 pp_decimal_int (buffer, bb->frequency);
2962 pp_string (buffer, " count:");
2963 pp_widest_integer (buffer, bb->count);
2966 if (flags & TDF_LINENO)
2968 block_stmt_iterator bsi;
2970 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2971 if (get_lineno (bsi_stmt (bsi)) != -1)
2973 pp_string (buffer, ", starting at line ");
2974 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2978 newline_and_indent (buffer, indent);
2980 pp_string (buffer, "# PRED:");
2981 pp_write_text_to_stream (buffer);
2982 FOR_EACH_EDGE (e, ei, bb->preds)
2983 if (flags & TDF_SLIM)
2985 pp_string (buffer, " ");
2986 if (e->src == ENTRY_BLOCK_PTR)
2987 pp_string (buffer, "ENTRY");
2989 pp_decimal_int (buffer, e->src->index);
2992 dump_edge_info (buffer->buffer->stream, e, 0);
2993 pp_newline (buffer);
2997 stmt = first_stmt (bb);
2998 if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
3000 INDENT (indent - 2);
3001 pp_string (buffer, "<bb ");
3002 pp_decimal_int (buffer, bb->index);
3003 pp_string (buffer, ">:");
3004 pp_newline (buffer);
3007 pp_write_text_to_stream (buffer);
3008 check_bb_profile (bb, buffer->buffer->stream);
3011 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
3015 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
3021 pp_string (buffer, "# SUCC:");
3022 pp_write_text_to_stream (buffer);
3023 FOR_EACH_EDGE (e, ei, bb->succs)
3024 if (flags & TDF_SLIM)
3026 pp_string (buffer, " ");
3027 if (e->dest == EXIT_BLOCK_PTR)
3028 pp_string (buffer, "EXIT");
3030 pp_decimal_int (buffer, e->dest->index);
3033 dump_edge_info (buffer->buffer->stream, e, 1);
3034 pp_newline (buffer);
3037 /* Dump PHI nodes of basic block BB to BUFFER with details described
3038 by FLAGS and indented by INDENT spaces. */
3041 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
3043 tree phi = phi_nodes (bb);
3047 for (; phi; phi = PHI_CHAIN (phi))
3049 if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
3052 pp_string (buffer, "# ");
3053 dump_generic_node (buffer, phi, indent, flags, false);
3054 pp_newline (buffer);
3060 /* Dump jump to basic block BB that is represented implicitly in the cfg
3064 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
3068 stmt = first_stmt (bb);
3070 pp_string (buffer, "goto <bb ");
3071 pp_decimal_int (buffer, bb->index);
3072 pp_string (buffer, ">");
3073 if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
3075 pp_string (buffer, " (");
3076 dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
3077 pp_string (buffer, ")");
3079 pp_semicolon (buffer);
3082 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
3083 by INDENT spaces, with details given by FLAGS. */
3086 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
3093 stmt = last_stmt (bb);
3094 if (stmt && TREE_CODE (stmt) == COND_EXPR)
3096 edge true_edge, false_edge;
3098 /* When we are emitting the code or changing CFG, it is possible that
3099 the edges are not yet created. When we are using debug_bb in such
3100 a situation, we do not want it to crash. */
3101 if (EDGE_COUNT (bb->succs) != 2)
3103 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
3105 INDENT (indent + 2);
3106 pp_cfg_jump (buffer, true_edge->dest);
3107 newline_and_indent (buffer, indent);
3108 pp_string (buffer, "else");
3109 newline_and_indent (buffer, indent + 2);
3110 pp_cfg_jump (buffer, false_edge->dest);
3111 pp_newline (buffer);
3115 /* If there is a fallthru edge, we may need to add an artificial goto to the
3117 FOR_EACH_EDGE (e, ei, bb->succs)
3118 if (e->flags & EDGE_FALLTHRU)
3120 if (e && e->dest != bb->next_bb)
3124 if ((flags & TDF_LINENO) && e->goto_locus != UNKNOWN_LOCATION)
3126 expanded_location goto_xloc;
3127 goto_xloc = expand_location (e->goto_locus);
3128 pp_character (buffer, '[');
3131 pp_string (buffer, goto_xloc.file);
3132 pp_string (buffer, " : ");
3134 pp_decimal_int (buffer, goto_xloc.line);
3135 pp_string (buffer, "] ");
3138 pp_cfg_jump (buffer, e->dest);
3139 pp_newline (buffer);
3143 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
3144 indented by INDENT spaces. */
3147 dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
3148 int indent, int flags)
3150 block_stmt_iterator bsi;
3152 int label_indent = indent - 2;
3154 if (label_indent < 0)
3157 dump_bb_header (buffer, bb, indent, flags);
3159 dump_phi_nodes (buffer, bb, indent, flags);
3161 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
3165 stmt = bsi_stmt (bsi);
3167 curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
3169 INDENT (curr_indent);
3170 dump_generic_node (buffer, stmt, curr_indent, flags, true);
3171 pp_newline (buffer);
3172 dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
3175 dump_implicit_edges (buffer, bb, indent, flags);
3177 if (flags & TDF_BLOCKS)
3178 dump_bb_end (buffer, bb, indent, flags);