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, high, low);
788 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
791 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
795 /* Code copied from print_node. */
798 if (TREE_OVERFLOW (node))
799 pp_string (buffer, " overflow");
801 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
802 d = TREE_REAL_CST (node);
803 if (REAL_VALUE_ISINF (d))
804 pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
805 else if (REAL_VALUE_ISNAN (d))
806 pp_string (buffer, " Nan");
810 real_to_decimal (string, &d, sizeof (string), 0, 1);
811 pp_string (buffer, string);
816 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
817 pp_string (buffer, "0x");
818 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
819 output_formatted_integer (buffer, "%02x", *p++);
828 fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
829 pp_string (buffer, string);
834 pp_string (buffer, "__complex__ (");
835 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
836 pp_string (buffer, ", ");
837 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
838 pp_string (buffer, ")");
842 pp_string (buffer, "\"");
843 pretty_print_string (buffer, TREE_STRING_POINTER (node));
844 pp_string (buffer, "\"");
850 pp_string (buffer, "{ ");
851 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
853 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
854 if (TREE_CHAIN (elt))
855 pp_string (buffer, ", ");
857 pp_string (buffer, " }");
866 dump_decl_name (buffer, node, flags);
870 if (DECL_NAME (node))
871 dump_decl_name (buffer, node, flags);
872 else if (LABEL_DECL_UID (node) != -1)
873 pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));
875 pp_printf (buffer, "<D.%u>", DECL_UID (node));
879 if (DECL_IS_BUILTIN (node))
881 /* Don't print the declaration of built-in types. */
884 if (DECL_NAME (node))
885 dump_decl_name (buffer, node, flags);
888 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
889 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
890 && TYPE_METHODS (TREE_TYPE (node)))
892 /* The type is a c++ class: all structures have at least
894 pp_string (buffer, "class ");
895 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
900 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
901 ? "union" : "struct "));
902 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
907 case SYMBOL_MEMORY_TAG:
908 case NAME_MEMORY_TAG:
909 case STRUCT_FIELD_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:
1427 type = TREE_TYPE (node);
1428 op0 = TREE_OPERAND (node, 0);
1429 if (type != TREE_TYPE (op0))
1431 pp_character (buffer, '(');
1432 dump_generic_node (buffer, type, spc, flags, false);
1433 pp_string (buffer, ") ");
1435 if (op_prio (op0) < op_prio (node))
1436 pp_character (buffer, '(');
1437 dump_generic_node (buffer, op0, spc, flags, false);
1438 if (op_prio (op0) < op_prio (node))
1439 pp_character (buffer, ')');
1442 case VIEW_CONVERT_EXPR:
1443 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1444 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1445 pp_string (buffer, ">(");
1446 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1447 pp_character (buffer, ')');
1451 pp_string (buffer, "((");
1452 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1453 pp_string (buffer, "))");
1456 case NON_LVALUE_EXPR:
1457 pp_string (buffer, "NON_LVALUE_EXPR <");
1458 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1459 pp_character (buffer, '>');
1463 pp_string (buffer, "SAVE_EXPR <");
1464 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1465 pp_character (buffer, '>');
1469 pp_string (buffer, "COMPLEX_EXPR <");
1470 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1471 pp_string (buffer, ", ");
1472 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1473 pp_string (buffer, ">");
1477 pp_string (buffer, "CONJ_EXPR <");
1478 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1479 pp_string (buffer, ">");
1483 pp_string (buffer, "REALPART_EXPR <");
1484 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1485 pp_string (buffer, ">");
1489 pp_string (buffer, "IMAGPART_EXPR <");
1490 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1491 pp_string (buffer, ">");
1495 pp_string (buffer, "VA_ARG_EXPR <");
1496 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1497 pp_string (buffer, ">");
1500 case TRY_FINALLY_EXPR:
1501 case TRY_CATCH_EXPR:
1502 pp_string (buffer, "try");
1503 newline_and_indent (buffer, spc+2);
1504 pp_string (buffer, "{");
1505 newline_and_indent (buffer, spc+4);
1506 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1507 newline_and_indent (buffer, spc+2);
1508 pp_string (buffer, "}");
1509 newline_and_indent (buffer, spc);
1511 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1512 newline_and_indent (buffer, spc+2);
1513 pp_string (buffer, "{");
1514 newline_and_indent (buffer, spc+4);
1515 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1516 newline_and_indent (buffer, spc+2);
1517 pp_string (buffer, "}");
1522 pp_string (buffer, "catch (");
1523 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1524 pp_string (buffer, ")");
1525 newline_and_indent (buffer, spc+2);
1526 pp_string (buffer, "{");
1527 newline_and_indent (buffer, spc+4);
1528 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1529 newline_and_indent (buffer, spc+2);
1530 pp_string (buffer, "}");
1534 case EH_FILTER_EXPR:
1535 pp_string (buffer, "<<<eh_filter (");
1536 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1537 pp_string (buffer, ")>>>");
1538 newline_and_indent (buffer, spc+2);
1539 pp_string (buffer, "{");
1540 newline_and_indent (buffer, spc+4);
1541 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1542 newline_and_indent (buffer, spc+2);
1543 pp_string (buffer, "}");
1547 case CHANGE_DYNAMIC_TYPE_EXPR:
1548 pp_string (buffer, "<<<change_dynamic_type (");
1549 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_NEW_TYPE (node), spc + 2,
1551 pp_string (buffer, ") ");
1552 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_LOCATION (node), spc + 2,
1554 pp_string (buffer, ")>>>");
1559 op0 = TREE_OPERAND (node, 0);
1560 /* If this is for break or continue, don't bother printing it. */
1561 if (DECL_NAME (op0))
1563 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1564 if (strcmp (name, "break") == 0
1565 || strcmp (name, "continue") == 0)
1568 dump_generic_node (buffer, op0, spc, flags, false);
1569 pp_character (buffer, ':');
1570 if (DECL_NONLOCAL (op0))
1571 pp_string (buffer, " [non-local]");
1575 pp_string (buffer, "<<<exception object>>>");
1579 pp_string (buffer, "<<<filter object>>>");
1583 pp_string (buffer, "while (1)");
1584 if (!(flags & TDF_SLIM))
1586 newline_and_indent (buffer, spc+2);
1587 pp_character (buffer, '{');
1588 newline_and_indent (buffer, spc+4);
1589 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1590 newline_and_indent (buffer, spc+2);
1591 pp_character (buffer, '}');
1597 pp_string (buffer, "// predicted ");
1598 if (PREDICT_EXPR_OUTCOME (node))
1599 pp_string (buffer, "likely by ");
1601 pp_string (buffer, "unlikely by ");
1602 pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
1603 pp_string (buffer, " predictor.");
1607 pp_string (buffer, "return");
1608 op0 = TREE_OPERAND (node, 0);
1612 if (TREE_CODE (op0) == MODIFY_EXPR
1613 || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
1614 dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
1617 dump_generic_node (buffer, op0, spc, flags, false);
1622 pp_string (buffer, "if (");
1623 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1624 pp_string (buffer, ") break");
1628 pp_string (buffer, "switch (");
1629 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1630 pp_character (buffer, ')');
1631 if (!(flags & TDF_SLIM))
1633 newline_and_indent (buffer, spc+2);
1634 pp_character (buffer, '{');
1635 if (SWITCH_BODY (node))
1637 newline_and_indent (buffer, spc+4);
1638 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1643 tree vec = SWITCH_LABELS (node);
1644 size_t i, n = TREE_VEC_LENGTH (vec);
1645 for (i = 0; i < n; ++i)
1647 tree elt = TREE_VEC_ELT (vec, i);
1648 newline_and_indent (buffer, spc+4);
1651 dump_generic_node (buffer, elt, spc+4, flags, false);
1652 pp_string (buffer, " goto ");
1653 dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1655 pp_semicolon (buffer);
1658 pp_string (buffer, "case ???: goto ???;");
1661 newline_and_indent (buffer, spc+2);
1662 pp_character (buffer, '}');
1668 op0 = GOTO_DESTINATION (node);
1669 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1671 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1672 if (strcmp (name, "break") == 0
1673 || strcmp (name, "continue") == 0)
1675 pp_string (buffer, name);
1679 pp_string (buffer, "goto ");
1680 dump_generic_node (buffer, op0, spc, flags, false);
1684 pp_string (buffer, "resx ");
1685 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1689 pp_string (buffer, "__asm__");
1690 if (ASM_VOLATILE_P (node))
1691 pp_string (buffer, " __volatile__");
1692 pp_character (buffer, '(');
1693 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1694 pp_character (buffer, ':');
1695 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1696 pp_character (buffer, ':');
1697 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1698 if (ASM_CLOBBERS (node))
1700 pp_character (buffer, ':');
1701 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1703 pp_string (buffer, ")");
1706 case CASE_LABEL_EXPR:
1707 if (CASE_LOW (node) && CASE_HIGH (node))
1709 pp_string (buffer, "case ");
1710 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1711 pp_string (buffer, " ... ");
1712 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1714 else if (CASE_LOW (node))
1716 pp_string (buffer, "case ");
1717 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1720 pp_string (buffer, "default ");
1721 pp_character (buffer, ':');
1725 pp_string (buffer, "OBJ_TYPE_REF(");
1726 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1727 pp_character (buffer, ';');
1728 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1729 pp_character (buffer, '-');
1730 pp_character (buffer, '>');
1731 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1732 pp_character (buffer, ')');
1739 dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1740 pp_string (buffer, " = PHI <");
1741 for (i = 0; i < PHI_NUM_ARGS (node); i++)
1743 dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1744 pp_string (buffer, "(");
1745 pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1746 pp_string (buffer, ")");
1747 if (i < PHI_NUM_ARGS (node) - 1)
1748 pp_string (buffer, ", ");
1750 pp_string (buffer, ">");
1752 if (stmt_references_memory_p (node) && (flags & TDF_MEMSYMS))
1753 dump_symbols (buffer, STORED_SYMS (node), flags);
1758 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1759 pp_string (buffer, "_");
1760 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1761 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1762 pp_string (buffer, "(ab)");
1763 else if (SSA_NAME_IS_DEFAULT_DEF (node))
1764 pp_string (buffer, "(D)");
1767 case WITH_SIZE_EXPR:
1768 pp_string (buffer, "WITH_SIZE_EXPR <");
1769 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1770 pp_string (buffer, ", ");
1771 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1772 pp_string (buffer, ">");
1776 pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1780 pp_string (buffer, "ASSERT_EXPR <");
1781 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1782 pp_string (buffer, ", ");
1783 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1784 pp_string (buffer, ">");
1788 pp_string (buffer, "scev_known");
1791 case SCEV_NOT_KNOWN:
1792 pp_string (buffer, "scev_not_known");
1795 case POLYNOMIAL_CHREC:
1796 pp_string (buffer, "{");
1797 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1798 pp_string (buffer, ", +, ");
1799 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1800 pp_string (buffer, "}_");
1801 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1805 case REALIGN_LOAD_EXPR:
1806 pp_string (buffer, "REALIGN_LOAD <");
1807 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1808 pp_string (buffer, ", ");
1809 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1810 pp_string (buffer, ", ");
1811 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1812 pp_string (buffer, ">");
1816 pp_string (buffer, " VEC_COND_EXPR < ");
1817 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1818 pp_string (buffer, " , ");
1819 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1820 pp_string (buffer, " , ");
1821 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1822 pp_string (buffer, " > ");
1826 pp_string (buffer, " DOT_PROD_EXPR < ");
1827 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1828 pp_string (buffer, ", ");
1829 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1830 pp_string (buffer, ", ");
1831 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1832 pp_string (buffer, " > ");
1836 pp_string (buffer, "#pragma omp parallel");
1837 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
1838 if (OMP_PARALLEL_FN (node))
1840 pp_string (buffer, " [child fn: ");
1841 dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);
1843 pp_string (buffer, " (");
1845 if (OMP_PARALLEL_DATA_ARG (node))
1846 dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,
1849 pp_string (buffer, "???");
1851 pp_string (buffer, ")]");
1855 if (!(flags & TDF_SLIM) && OMP_BODY (node))
1857 newline_and_indent (buffer, spc + 2);
1858 pp_character (buffer, '{');
1859 newline_and_indent (buffer, spc + 4);
1860 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
1861 newline_and_indent (buffer, spc + 2);
1862 pp_character (buffer, '}');
1868 pp_string (buffer, "#pragma omp for");
1869 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
1871 if (!(flags & TDF_SLIM))
1873 if (OMP_FOR_PRE_BODY (node))
1875 newline_and_indent (buffer, spc + 2);
1876 pp_character (buffer, '{');
1878 newline_and_indent (buffer, spc);
1879 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
1882 newline_and_indent (buffer, spc);
1883 pp_string (buffer, "for (");
1884 dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);
1885 pp_string (buffer, "; ");
1886 dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);
1887 pp_string (buffer, "; ");
1888 dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);
1889 pp_string (buffer, ")");
1890 if (OMP_FOR_BODY (node))
1892 newline_and_indent (buffer, spc + 2);
1893 pp_character (buffer, '{');
1894 newline_and_indent (buffer, spc + 4);
1895 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
1897 newline_and_indent (buffer, spc + 2);
1898 pp_character (buffer, '}');
1900 if (OMP_FOR_PRE_BODY (node))
1903 newline_and_indent (buffer, spc + 2);
1904 pp_character (buffer, '}');
1911 pp_string (buffer, "#pragma omp sections");
1912 if (OMP_SECTIONS_CONTROL (node))
1914 pp_string (buffer, " <");
1915 dump_generic_node (buffer, OMP_SECTIONS_CONTROL (node), spc,
1917 pp_string (buffer, ">");
1919 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
1922 case OMP_SECTIONS_SWITCH:
1923 pp_string (buffer, "OMP_SECTIONS_SWITCH");
1928 pp_string (buffer, "#pragma omp section");
1932 pp_string (buffer, "#pragma omp master");
1936 pp_string (buffer, "#pragma omp ordered");
1940 pp_string (buffer, "#pragma omp critical");
1941 if (OMP_CRITICAL_NAME (node))
1944 pp_character (buffer, '(');
1945 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
1947 pp_character (buffer, ')');
1952 pp_string (buffer, "#pragma omp atomic");
1953 newline_and_indent (buffer, spc + 2);
1954 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1956 pp_character (buffer, '=');
1958 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1961 case OMP_ATOMIC_LOAD:
1962 pp_string (buffer, "#pragma omp atomic_load");
1963 newline_and_indent (buffer, spc + 2);
1964 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1966 pp_character (buffer, '=');
1968 pp_character (buffer, '*');
1969 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1972 case OMP_ATOMIC_STORE:
1973 pp_string (buffer, "#pragma omp atomic_store (");
1974 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1975 pp_character (buffer, ')');
1979 pp_string (buffer, "#pragma omp single");
1980 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
1984 pp_string (buffer, "OMP_RETURN");
1985 if (OMP_RETURN_NOWAIT (node))
1986 pp_string (buffer, " [nowait]");
1991 pp_string (buffer, "OMP_CONTINUE <");
1992 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1993 pp_string (buffer, " <- ");
1994 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1995 pp_string (buffer, ">");
2000 dump_omp_clause (buffer, node, spc, flags);
2004 case REDUC_MAX_EXPR:
2005 pp_string (buffer, " REDUC_MAX_EXPR < ");
2006 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2007 pp_string (buffer, " > ");
2010 case REDUC_MIN_EXPR:
2011 pp_string (buffer, " REDUC_MIN_EXPR < ");
2012 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2013 pp_string (buffer, " > ");
2016 case REDUC_PLUS_EXPR:
2017 pp_string (buffer, " REDUC_PLUS_EXPR < ");
2018 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2019 pp_string (buffer, " > ");
2022 case VEC_WIDEN_MULT_HI_EXPR:
2023 pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
2024 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2025 pp_string (buffer, ", ");
2026 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2027 pp_string (buffer, " > ");
2030 case VEC_WIDEN_MULT_LO_EXPR:
2031 pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
2032 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2033 pp_string (buffer, ", ");
2034 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2035 pp_string (buffer, " > ");
2038 case VEC_UNPACK_HI_EXPR:
2039 pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
2040 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2041 pp_string (buffer, " > ");
2044 case VEC_UNPACK_LO_EXPR:
2045 pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
2046 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2047 pp_string (buffer, " > ");
2050 case VEC_UNPACK_FLOAT_HI_EXPR:
2051 pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2052 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2053 pp_string (buffer, " > ");
2056 case VEC_UNPACK_FLOAT_LO_EXPR:
2057 pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2058 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2059 pp_string (buffer, " > ");
2062 case VEC_PACK_TRUNC_EXPR:
2063 pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
2064 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2065 pp_string (buffer, ", ");
2066 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2067 pp_string (buffer, " > ");
2070 case VEC_PACK_SAT_EXPR:
2071 pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
2072 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2073 pp_string (buffer, ", ");
2074 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2075 pp_string (buffer, " > ");
2078 case VEC_PACK_FIX_TRUNC_EXPR:
2079 pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");
2080 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2081 pp_string (buffer, ", ");
2082 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2083 pp_string (buffer, " > ");
2089 pp_string (buffer, "BLOCK");
2091 if (BLOCK_ABSTRACT (node))
2092 pp_string (buffer, " [abstract]");
2094 if (TREE_ASM_WRITTEN (node))
2095 pp_string (buffer, " [written]");
2097 newline_and_indent (buffer, spc + 2);
2099 if (BLOCK_SUPERCONTEXT (node))
2101 pp_string (buffer, "SUPERCONTEXT: ");
2102 if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
2103 pp_printf (buffer, "BLOCK %p",
2104 (void *)BLOCK_SUPERCONTEXT (node));
2106 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
2108 newline_and_indent (buffer, spc + 2);
2111 if (BLOCK_SUBBLOCKS (node))
2113 pp_string (buffer, "SUBBLOCKS: ");
2114 for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
2115 pp_printf (buffer, "%p ", (void *)t);
2116 newline_and_indent (buffer, spc + 2);
2119 if (BLOCK_VARS (node))
2121 pp_string (buffer, "VARS: ");
2122 for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
2124 dump_generic_node (buffer, t, 0, flags, false);
2125 pp_string (buffer, " ");
2127 newline_and_indent (buffer, spc + 2);
2130 if (BLOCK_ABSTRACT_ORIGIN (node))
2132 pp_string (buffer, "ABSTRACT_ORIGIN: ");
2133 if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
2134 pp_printf (buffer, "BLOCK %p",
2135 (void *)BLOCK_ABSTRACT_ORIGIN (node));
2137 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
2139 newline_and_indent (buffer, spc + 2);
2144 case VEC_EXTRACT_EVEN_EXPR:
2145 pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
2146 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2147 pp_string (buffer, ", ");
2148 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2149 pp_string (buffer, " > ");
2152 case VEC_EXTRACT_ODD_EXPR:
2153 pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
2154 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2155 pp_string (buffer, ", ");
2156 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2157 pp_string (buffer, " > ");
2160 case VEC_INTERLEAVE_HIGH_EXPR:
2161 pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
2162 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2163 pp_string (buffer, ", ");
2164 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2165 pp_string (buffer, " > ");
2168 case VEC_INTERLEAVE_LOW_EXPR:
2169 pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
2170 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2171 pp_string (buffer, ", ");
2172 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2173 pp_string (buffer, " > ");
2180 if (is_stmt && is_expr)
2181 pp_semicolon (buffer);
2183 /* If we're building a diagnostic, the formatted text will be written
2184 into BUFFER's stream by the caller; otherwise, write it now. */
2185 if (!(flags & TDF_DIAGNOSTIC))
2186 pp_write_text_to_stream (buffer);
2191 /* Print the declaration of a variable. */
2194 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2198 if (TREE_CODE (t) == TYPE_DECL)
2199 pp_string (buffer, "typedef ");
2201 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2202 pp_string (buffer, "register ");
2204 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2205 pp_string (buffer, "extern ");
2206 else if (TREE_STATIC (t))
2207 pp_string (buffer, "static ");
2209 /* Print the type and name. */
2210 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2214 /* Print array's type. */
2215 tmp = TREE_TYPE (t);
2216 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2217 tmp = TREE_TYPE (tmp);
2218 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2220 /* Print variable's name. */
2222 dump_generic_node (buffer, t, spc, flags, false);
2224 /* Print the dimensions. */
2225 tmp = TREE_TYPE (t);
2226 while (TREE_CODE (tmp) == ARRAY_TYPE)
2228 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
2229 tmp = TREE_TYPE (tmp);
2232 else if (TREE_CODE (t) == FUNCTION_DECL)
2234 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2236 dump_decl_name (buffer, t, flags);
2237 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2241 /* Print type declaration. */
2242 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2244 /* Print variable's name. */
2246 dump_generic_node (buffer, t, spc, flags, false);
2249 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2251 pp_string (buffer, " __asm__ ");
2252 pp_character (buffer, '(');
2253 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2254 pp_character (buffer, ')');
2257 /* The initial value of a function serves to determine wether the function
2258 is declared or defined. So the following does not apply to function
2260 if (TREE_CODE (t) != FUNCTION_DECL)
2262 /* Print the initial value. */
2263 if (DECL_INITIAL (t))
2266 pp_character (buffer, '=');
2268 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2272 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2274 pp_string (buffer, " [value-expr: ");
2275 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2276 pp_character (buffer, ']');
2279 pp_character (buffer, ';');
2283 /* Prints a structure: name, fields, and methods.
2284 FIXME: Still incomplete. */
2287 print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
2289 /* Print the name of the structure. */
2290 if (TYPE_NAME (node))
2293 if (TREE_CODE (node) == RECORD_TYPE)
2294 pp_string (buffer, "struct ");
2295 else if ((TREE_CODE (node) == UNION_TYPE
2296 || TREE_CODE (node) == QUAL_UNION_TYPE))
2297 pp_string (buffer, "union ");
2299 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2302 /* Print the contents of the structure. */
2303 pp_newline (buffer);
2305 pp_character (buffer, '{');
2306 pp_newline (buffer);
2308 /* Print the fields of the structure. */
2311 tmp = TYPE_FIELDS (node);
2314 /* Avoid to print recursively the structure. */
2315 /* FIXME : Not implemented correctly...,
2316 what about the case when we have a cycle in the contain graph? ...
2317 Maybe this could be solved by looking at the scope in which the
2318 structure was declared. */
2319 if (TREE_TYPE (tmp) != node
2320 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
2321 && TREE_TYPE (TREE_TYPE (tmp)) != node))
2323 print_declaration (buffer, tmp, spc+2, flags);
2324 pp_newline (buffer);
2326 tmp = TREE_CHAIN (tmp);
2330 pp_character (buffer, '}');
2333 /* Return the priority of the operator OP.
2335 From lowest to highest precedence with either left-to-right (L-R)
2336 or right-to-left (R-L) associativity]:
2339 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2351 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2352 15 [L-R] fn() [] -> .
2354 unary +, - and * have higher precedence than the corresponding binary
2358 op_prio (const_tree op)
2363 switch (TREE_CODE (op))
2371 case GIMPLE_MODIFY_STMT:
2379 case TRUTH_ORIF_EXPR:
2382 case TRUTH_AND_EXPR:
2383 case TRUTH_ANDIF_EXPR:
2390 case TRUTH_XOR_EXPR:
2407 case UNORDERED_EXPR:
2420 case WIDEN_SUM_EXPR:
2422 case POINTER_PLUS_EXPR:
2426 case VEC_WIDEN_MULT_HI_EXPR:
2427 case VEC_WIDEN_MULT_LO_EXPR:
2428 case WIDEN_MULT_EXPR:
2431 case TRUNC_DIV_EXPR:
2433 case FLOOR_DIV_EXPR:
2434 case ROUND_DIV_EXPR:
2436 case EXACT_DIV_EXPR:
2437 case TRUNC_MOD_EXPR:
2439 case FLOOR_MOD_EXPR:
2440 case ROUND_MOD_EXPR:
2443 case TRUTH_NOT_EXPR:
2445 case POSTINCREMENT_EXPR:
2446 case POSTDECREMENT_EXPR:
2447 case PREINCREMENT_EXPR:
2448 case PREDECREMENT_EXPR:
2450 case ALIGN_INDIRECT_REF:
2451 case MISALIGNED_INDIRECT_REF:
2457 case FIX_TRUNC_EXPR:
2463 case ARRAY_RANGE_REF:
2467 /* Special expressions. */
2473 case REDUC_MAX_EXPR:
2474 case REDUC_MIN_EXPR:
2475 case REDUC_PLUS_EXPR:
2476 case VEC_LSHIFT_EXPR:
2477 case VEC_RSHIFT_EXPR:
2478 case VEC_UNPACK_HI_EXPR:
2479 case VEC_UNPACK_LO_EXPR:
2480 case VEC_UNPACK_FLOAT_HI_EXPR:
2481 case VEC_UNPACK_FLOAT_LO_EXPR:
2482 case VEC_PACK_TRUNC_EXPR:
2483 case VEC_PACK_SAT_EXPR:
2487 case NON_LVALUE_EXPR:
2488 return op_prio (TREE_OPERAND (op, 0));
2491 /* Return an arbitrarily high precedence to avoid surrounding single
2492 VAR_DECLs in ()s. */
2498 /* Return the symbol associated with operator CODE. */
2501 op_symbol_code (enum tree_code code)
2506 case GIMPLE_MODIFY_STMT:
2510 case TRUTH_ORIF_EXPR:
2513 case TRUTH_AND_EXPR:
2514 case TRUTH_ANDIF_EXPR:
2520 case TRUTH_XOR_EXPR:
2530 case UNORDERED_EXPR:
2576 case VEC_LSHIFT_EXPR:
2579 case VEC_RSHIFT_EXPR:
2582 case POINTER_PLUS_EXPR:
2588 case REDUC_PLUS_EXPR:
2591 case WIDEN_SUM_EXPR:
2594 case WIDEN_MULT_EXPR:
2604 case TRUTH_NOT_EXPR:
2611 case ALIGN_INDIRECT_REF:
2614 case MISALIGNED_INDIRECT_REF:
2617 case TRUNC_DIV_EXPR:
2624 case FLOOR_DIV_EXPR:
2627 case ROUND_DIV_EXPR:
2630 case EXACT_DIV_EXPR:
2633 case TRUNC_MOD_EXPR:
2639 case FLOOR_MOD_EXPR:
2642 case ROUND_MOD_EXPR:
2645 case PREDECREMENT_EXPR:
2648 case PREINCREMENT_EXPR:
2651 case POSTDECREMENT_EXPR:
2654 case POSTINCREMENT_EXPR:
2664 return "<<< ??? >>>";
2668 /* Return the symbol associated with operator OP. */
2671 op_symbol (const_tree op)
2673 return op_symbol_code (TREE_CODE (op));
2676 /* Prints the name of a CALL_EXPR. */
2679 print_call_name (pretty_printer *buffer, const_tree node)
2683 gcc_assert (TREE_CODE (node) == CALL_EXPR);
2685 op0 = CALL_EXPR_FN (node);
2687 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2688 op0 = TREE_OPERAND (op0, 0);
2690 switch (TREE_CODE (op0))
2694 dump_function_name (buffer, op0);
2700 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2704 pp_string (buffer, "(");
2705 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2706 pp_string (buffer, ") ? ");
2707 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
2708 pp_string (buffer, " : ");
2709 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
2713 /* The function is a pointer contained in a structure. */
2714 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
2715 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2716 dump_function_name (buffer, TREE_OPERAND (op0, 1));
2718 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2720 We can have several levels of structures and a function
2721 pointer inside. This is not implemented yet... */
2726 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2727 dump_function_name (buffer, TREE_OPERAND (op0, 0));
2729 dump_generic_node (buffer, op0, 0, 0, false);
2734 dump_generic_node (buffer, op0, 0, 0, false);
2742 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2745 pretty_print_string (pretty_printer *buffer, const char *str)
2755 pp_string (buffer, "\\b");
2759 pp_string (buffer, "\\f");
2763 pp_string (buffer, "\\n");
2767 pp_string (buffer, "\\r");
2771 pp_string (buffer, "\\t");
2775 pp_string (buffer, "\\v");
2779 pp_string (buffer, "\\\\");
2783 pp_string (buffer, "\\\"");
2787 pp_string (buffer, "\\'");
2790 /* No need to handle \0; the loop terminates on \0. */
2793 pp_string (buffer, "\\1");
2797 pp_string (buffer, "\\2");
2801 pp_string (buffer, "\\3");
2805 pp_string (buffer, "\\4");
2809 pp_string (buffer, "\\5");
2813 pp_string (buffer, "\\6");
2817 pp_string (buffer, "\\7");
2821 pp_character (buffer, str[0]);
2829 maybe_init_pretty_print (FILE *file)
2833 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2834 pp_needs_newline (&buffer) = true;
2838 buffer.buffer->stream = file;
2842 newline_and_indent (pretty_printer *buffer, int spc)
2844 pp_newline (buffer);
2850 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2852 struct voptype_d *vdefs;
2853 struct voptype_d *vuses;
2856 if (!ssa_operands_active () || !stmt_references_memory_p (stmt))
2859 /* Even if the statement doesn't have virtual operators yet, it may
2860 contain symbol information (this happens before aliases have been
2862 if ((flags & TDF_MEMSYMS)
2863 && VUSE_OPS (stmt) == NULL
2864 && VDEF_OPS (stmt) == NULL)
2866 if (LOADED_SYMS (stmt))
2868 pp_string (buffer, "# LOADS: ");
2869 dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2870 newline_and_indent (buffer, spc);
2873 if (STORED_SYMS (stmt))
2875 pp_string (buffer, "# STORES: ");
2876 dump_symbols (buffer, STORED_SYMS (stmt), flags);
2877 newline_and_indent (buffer, spc);
2883 vuses = VUSE_OPS (stmt);
2886 pp_string (buffer, "# VUSE <");
2888 n = VUSE_NUM (vuses);
2889 for (i = 0; i < n; i++)
2891 dump_generic_node (buffer, VUSE_OP (vuses, i), spc + 2, flags, false);
2893 pp_string (buffer, ", ");
2896 pp_string (buffer, ">");
2898 if (flags & TDF_MEMSYMS)
2899 dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2901 newline_and_indent (buffer, spc);
2902 vuses = vuses->next;
2905 vdefs = VDEF_OPS (stmt);
2908 pp_string (buffer, "# ");
2909 dump_generic_node (buffer, VDEF_RESULT (vdefs), spc + 2, flags, false);
2910 pp_string (buffer, " = VDEF <");
2912 n = VDEF_NUM (vdefs);
2913 for (i = 0; i < n; i++)
2915 dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, 0);
2917 pp_string (buffer, ", ");
2920 pp_string (buffer, ">");
2922 if ((flags & TDF_MEMSYMS) && vdefs->next == NULL)
2923 dump_symbols (buffer, STORED_SYMS (stmt), flags);
2925 newline_and_indent (buffer, spc);
2926 vdefs = vdefs->next;
2931 /* Dumps basic block BB to FILE with details described by FLAGS and
2932 indented by INDENT spaces. */
2935 dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2937 maybe_init_pretty_print (file);
2938 dump_generic_bb_buff (&buffer, bb, indent, flags);
2942 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2943 spaces and details described by flags. */
2946 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2952 if (flags & TDF_BLOCKS)
2955 pp_string (buffer, "# BLOCK ");
2956 pp_decimal_int (buffer, bb->index);
2959 pp_string (buffer, " freq:");
2960 pp_decimal_int (buffer, bb->frequency);
2964 pp_string (buffer, " count:");
2965 pp_widest_integer (buffer, bb->count);
2968 if (flags & TDF_LINENO)
2970 block_stmt_iterator bsi;
2972 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2973 if (get_lineno (bsi_stmt (bsi)) != -1)
2975 pp_string (buffer, ", starting at line ");
2976 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2980 newline_and_indent (buffer, indent);
2982 pp_string (buffer, "# PRED:");
2983 pp_write_text_to_stream (buffer);
2984 FOR_EACH_EDGE (e, ei, bb->preds)
2985 if (flags & TDF_SLIM)
2987 pp_string (buffer, " ");
2988 if (e->src == ENTRY_BLOCK_PTR)
2989 pp_string (buffer, "ENTRY");
2991 pp_decimal_int (buffer, e->src->index);
2994 dump_edge_info (buffer->buffer->stream, e, 0);
2995 pp_newline (buffer);
2999 stmt = first_stmt (bb);
3000 if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
3002 INDENT (indent - 2);
3003 pp_string (buffer, "<bb ");
3004 pp_decimal_int (buffer, bb->index);
3005 pp_string (buffer, ">:");
3006 pp_newline (buffer);
3009 pp_write_text_to_stream (buffer);
3010 check_bb_profile (bb, buffer->buffer->stream);
3013 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
3017 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
3023 pp_string (buffer, "# SUCC:");
3024 pp_write_text_to_stream (buffer);
3025 FOR_EACH_EDGE (e, ei, bb->succs)
3026 if (flags & TDF_SLIM)
3028 pp_string (buffer, " ");
3029 if (e->dest == EXIT_BLOCK_PTR)
3030 pp_string (buffer, "EXIT");
3032 pp_decimal_int (buffer, e->dest->index);
3035 dump_edge_info (buffer->buffer->stream, e, 1);
3036 pp_newline (buffer);
3039 /* Dump PHI nodes of basic block BB to BUFFER with details described
3040 by FLAGS and indented by INDENT spaces. */
3043 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
3045 tree phi = phi_nodes (bb);
3049 for (; phi; phi = PHI_CHAIN (phi))
3051 if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
3054 pp_string (buffer, "# ");
3055 dump_generic_node (buffer, phi, indent, flags, false);
3056 pp_newline (buffer);
3062 /* Dump jump to basic block BB that is represented implicitly in the cfg
3066 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
3070 stmt = first_stmt (bb);
3072 pp_string (buffer, "goto <bb ");
3073 pp_decimal_int (buffer, bb->index);
3074 pp_string (buffer, ">");
3075 if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
3077 pp_string (buffer, " (");
3078 dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
3079 pp_string (buffer, ")");
3081 pp_semicolon (buffer);
3084 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
3085 by INDENT spaces, with details given by FLAGS. */
3088 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
3095 stmt = last_stmt (bb);
3096 if (stmt && TREE_CODE (stmt) == COND_EXPR)
3098 edge true_edge, false_edge;
3100 /* When we are emitting the code or changing CFG, it is possible that
3101 the edges are not yet created. When we are using debug_bb in such
3102 a situation, we do not want it to crash. */
3103 if (EDGE_COUNT (bb->succs) != 2)
3105 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
3107 INDENT (indent + 2);
3108 pp_cfg_jump (buffer, true_edge->dest);
3109 newline_and_indent (buffer, indent);
3110 pp_string (buffer, "else");
3111 newline_and_indent (buffer, indent + 2);
3112 pp_cfg_jump (buffer, false_edge->dest);
3113 pp_newline (buffer);
3117 /* If there is a fallthru edge, we may need to add an artificial goto to the
3119 FOR_EACH_EDGE (e, ei, bb->succs)
3120 if (e->flags & EDGE_FALLTHRU)
3122 if (e && e->dest != bb->next_bb)
3126 if ((flags & TDF_LINENO) && e->goto_locus != UNKNOWN_LOCATION)
3128 expanded_location goto_xloc;
3129 goto_xloc = expand_location (e->goto_locus);
3130 pp_character (buffer, '[');
3133 pp_string (buffer, goto_xloc.file);
3134 pp_string (buffer, " : ");
3136 pp_decimal_int (buffer, goto_xloc.line);
3137 pp_string (buffer, "] ");
3140 pp_cfg_jump (buffer, e->dest);
3141 pp_newline (buffer);
3145 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
3146 indented by INDENT spaces. */
3149 dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
3150 int indent, int flags)
3152 block_stmt_iterator bsi;
3154 int label_indent = indent - 2;
3156 if (label_indent < 0)
3159 dump_bb_header (buffer, bb, indent, flags);
3161 dump_phi_nodes (buffer, bb, indent, flags);
3163 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
3167 stmt = bsi_stmt (bsi);
3169 curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
3171 INDENT (curr_indent);
3172 dump_generic_node (buffer, stmt, curr_indent, flags, true);
3173 pp_newline (buffer);
3174 dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
3177 dump_implicit_edges (buffer, bb, indent, flags);
3179 if (flags & TDF_BLOCKS)
3180 dump_bb_end (buffer, bb, indent, flags);