1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
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"
27 #include "diagnostic.h"
30 #include "tree-flow.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
33 #include "tree-chrec.h"
34 #include "tree-pass.h"
35 #include "value-prof.h"
37 /* Local functions, macros and variables. */
38 static int op_prio (tree);
39 static const char *op_symbol (tree);
40 static void pretty_print_string (pretty_printer *, const char*);
41 static void print_call_name (pretty_printer *, tree);
42 static void newline_and_indent (pretty_printer *, int);
43 static void maybe_init_pretty_print (FILE *);
44 static void print_declaration (pretty_printer *, tree, int, int);
45 static void print_struct_decl (pretty_printer *, tree, int, int);
46 static void do_niy (pretty_printer *, tree);
47 static void dump_vops (pretty_printer *, tree, int, int);
48 static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
50 #define INDENT(SPACE) do { \
51 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
53 #define NIY do_niy(buffer,node)
55 #define PRINT_FUNCTION_NAME(NODE) pp_printf \
56 (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \
57 lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
58 lang_hooks.decl_printable_name (NODE, 1))
60 static pretty_printer buffer;
61 static int initialized = 0;
63 /* Try to print something for an unknown tree code. */
66 do_niy (pretty_printer *buffer, tree node)
70 pp_string (buffer, "<<< Unknown tree: ");
71 pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
75 len = TREE_OPERAND_LENGTH (node);
76 for (i = 0; i < len; ++i)
78 newline_and_indent (buffer, 2);
79 dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);
83 pp_string (buffer, " >>>\n");
87 debug_generic_expr (tree t)
89 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
90 fprintf (stderr, "\n");
94 debug_generic_stmt (tree t)
96 print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
97 fprintf (stderr, "\n");
101 debug_tree_chain (tree t)
105 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
106 fprintf(stderr, " ");
109 fprintf (stderr, "\n");
112 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
114 print_generic_decl (FILE *file, tree decl, int flags)
116 maybe_init_pretty_print (file);
117 print_declaration (&buffer, decl, 2, flags);
118 pp_write_text_to_stream (&buffer);
121 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
122 to show in the dump. See TDF_* in tree.h. */
125 print_generic_stmt (FILE *file, tree t, int flags)
127 maybe_init_pretty_print (file);
128 dump_generic_node (&buffer, t, 0, flags, true);
132 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
133 to show in the dump. See TDF_* in tree.h. The output is indented by
137 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
141 maybe_init_pretty_print (file);
143 for (i = 0; i < indent; i++)
145 dump_generic_node (&buffer, t, indent, flags, true);
149 /* Print a single expression T on file FILE. FLAGS specifies details to show
150 in the dump. See TDF_* in tree.h. */
153 print_generic_expr (FILE *file, tree t, int flags)
155 maybe_init_pretty_print (file);
156 dump_generic_node (&buffer, t, 0, flags, false);
159 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
163 dump_decl_name (pretty_printer *buffer, tree node, int flags)
168 pp_tree_identifier (buffer, DECL_NAME (t));
169 if ((flags & TDF_UID)
170 || DECL_NAME (t) == NULL_TREE)
172 if (TREE_CODE (t) == LABEL_DECL
173 && LABEL_DECL_UID (t) != -1)
174 pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
178 char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
179 pp_printf (buffer, "%c.%u", c, DECL_UID (t));
184 /* Like the above, but used for pretty printing function calls. */
187 dump_function_name (pretty_printer *buffer, tree node)
189 if (DECL_NAME (node))
190 PRINT_FUNCTION_NAME (node);
192 dump_decl_name (buffer, node, 0);
195 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
196 FLAGS are as in dump_generic_node. */
199 dump_function_declaration (pretty_printer *buffer, tree node,
202 bool wrote_arg = false;
206 pp_character (buffer, '(');
208 /* Print the argument types. The last element in the list is a VOID_TYPE.
209 The following avoids printing the last element. */
210 arg = TYPE_ARG_TYPES (node);
211 while (arg && TREE_CHAIN (arg) && arg != error_mark_node)
214 dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
215 arg = TREE_CHAIN (arg);
216 if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)
218 pp_character (buffer, ',');
224 pp_string (buffer, "void");
226 pp_character (buffer, ')');
229 /* Dump the domain associated with an array. */
232 dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
234 pp_character (buffer, '[');
237 tree min = TYPE_MIN_VALUE (domain);
238 tree max = TYPE_MAX_VALUE (domain);
241 && integer_zerop (min)
242 && host_integerp (max, 0))
243 pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
247 dump_generic_node (buffer, min, spc, flags, false);
248 pp_character (buffer, ':');
250 dump_generic_node (buffer, max, spc, flags, false);
254 pp_string (buffer, "<unknown>");
255 pp_character (buffer, ']');
259 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
260 dump_generic_node. */
263 dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
267 switch (OMP_CLAUSE_CODE (clause))
269 case OMP_CLAUSE_PRIVATE:
272 case OMP_CLAUSE_SHARED:
275 case OMP_CLAUSE_FIRSTPRIVATE:
276 name = "firstprivate";
278 case OMP_CLAUSE_LASTPRIVATE:
279 name = "lastprivate";
281 case OMP_CLAUSE_COPYIN:
284 case OMP_CLAUSE_COPYPRIVATE:
285 name = "copyprivate";
288 pp_string (buffer, name);
289 pp_character (buffer, '(');
290 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
292 pp_character (buffer, ')');
295 case OMP_CLAUSE_REDUCTION:
296 pp_string (buffer, "reduction(");
297 pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
298 pp_character (buffer, ':');
299 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
301 pp_character (buffer, ')');
305 pp_string (buffer, "if(");
306 dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
308 pp_character (buffer, ')');
311 case OMP_CLAUSE_NUM_THREADS:
312 pp_string (buffer, "num_threads(");
313 dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
315 pp_character (buffer, ')');
318 case OMP_CLAUSE_NOWAIT:
319 pp_string (buffer, "nowait");
321 case OMP_CLAUSE_ORDERED:
322 pp_string (buffer, "ordered");
325 case OMP_CLAUSE_DEFAULT:
326 pp_string (buffer, "default(");
327 switch (OMP_CLAUSE_DEFAULT_KIND (clause))
329 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
331 case OMP_CLAUSE_DEFAULT_SHARED:
332 pp_string (buffer, "shared");
334 case OMP_CLAUSE_DEFAULT_NONE:
335 pp_string (buffer, "none");
337 case OMP_CLAUSE_DEFAULT_PRIVATE:
338 pp_string (buffer, "private");
343 pp_character (buffer, ')');
346 case OMP_CLAUSE_SCHEDULE:
347 pp_string (buffer, "schedule(");
348 switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
350 case OMP_CLAUSE_SCHEDULE_STATIC:
351 pp_string (buffer, "static");
353 case OMP_CLAUSE_SCHEDULE_DYNAMIC:
354 pp_string (buffer, "dynamic");
356 case OMP_CLAUSE_SCHEDULE_GUIDED:
357 pp_string (buffer, "guided");
359 case OMP_CLAUSE_SCHEDULE_RUNTIME:
360 pp_string (buffer, "runtime");
365 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
367 pp_character (buffer, ',');
368 dump_generic_node (buffer,
369 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
372 pp_character (buffer, ')');
376 /* Should never happen. */
377 dump_generic_node (buffer, clause, spc, flags, false);
383 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
384 dump_generic_node. */
387 dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
395 dump_omp_clause (buffer, clause, spc, flags);
396 clause = OMP_CLAUSE_CHAIN (clause);
404 /* Dump the set of decls SYMS. BUFFER, SPC and FLAGS are as in
405 dump_generic_node. */
408 dump_symbols (pretty_printer *buffer, bitmap syms, int flags)
414 pp_string (buffer, "NIL");
417 pp_string (buffer, " { ");
419 EXECUTE_IF_SET_IN_BITMAP (syms, 0, i, bi)
421 tree sym = referenced_var_lookup (i);
422 dump_generic_node (buffer, sym, 0, flags, false);
423 pp_string (buffer, " ");
426 pp_string (buffer, "}");
431 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
432 FLAGS specifies details to show in the dump (see TDF_* in tree-pass.h).
433 If IS_STMT is true, the object printed is considered to be a statement
434 and it is terminated by ';' if appropriate. */
437 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
445 if (node == NULL_TREE)
448 is_expr = EXPR_P (node) || GIMPLE_STMT_P (node);
450 /* We use has_stmt_ann because CALL_EXPR can be both an expression
451 and a statement, and we have no guarantee that it will have a
452 stmt_ann when it is used as an RHS expression. stmt_ann will assert
453 if you call it on something with a non-stmt annotation attached. */
454 if (TREE_CODE (node) != ERROR_MARK
455 && is_gimple_stmt (node)
456 && (flags & (TDF_VOPS|TDF_MEMSYMS))
457 && has_stmt_ann (node)
458 && TREE_CODE (node) != PHI_NODE)
459 dump_vops (buffer, node, spc, flags);
461 if (is_stmt && (flags & TDF_STMTADDR))
462 pp_printf (buffer, "<&%p> ", (void *)node);
464 if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
466 expanded_location xloc = expand_location (EXPR_LOCATION (node));
467 pp_character (buffer, '[');
470 pp_string (buffer, xloc.file);
471 pp_string (buffer, " : ");
473 pp_decimal_int (buffer, xloc.line);
474 pp_string (buffer, "] ");
477 switch (TREE_CODE (node))
480 pp_string (buffer, "<<< error >>>");
483 case IDENTIFIER_NODE:
484 pp_tree_identifier (buffer, node);
488 while (node && node != error_mark_node)
490 if (TREE_PURPOSE (node))
492 dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
495 dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
496 node = TREE_CHAIN (node);
497 if (node && TREE_CODE (node) == TREE_LIST)
499 pp_character (buffer, ',');
506 dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
511 if (TREE_VEC_LENGTH (node) > 0)
513 size_t len = TREE_VEC_LENGTH (node);
514 for (i = 0; i < len - 1; i++)
516 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
518 pp_character (buffer, ',');
521 dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
535 unsigned int quals = TYPE_QUALS (node);
536 enum tree_code_class class;
538 if (quals & TYPE_QUAL_CONST)
539 pp_string (buffer, "const ");
540 else if (quals & TYPE_QUAL_VOLATILE)
541 pp_string (buffer, "volatile ");
542 else if (quals & TYPE_QUAL_RESTRICT)
543 pp_string (buffer, "restrict ");
545 class = TREE_CODE_CLASS (TREE_CODE (node));
547 if (class == tcc_declaration)
549 if (DECL_NAME (node))
550 dump_decl_name (buffer, node, flags);
552 pp_string (buffer, "<unnamed type decl>");
554 else if (class == tcc_type)
556 if (TYPE_NAME (node))
558 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
559 pp_tree_identifier (buffer, TYPE_NAME (node));
560 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
561 && DECL_NAME (TYPE_NAME (node)))
562 dump_decl_name (buffer, TYPE_NAME (node), flags);
564 pp_string (buffer, "<unnamed type>");
566 else if (TREE_CODE (node) == VECTOR_TYPE)
568 pp_string (buffer, "vector ");
569 dump_generic_node (buffer, TREE_TYPE (node),
572 else if (TREE_CODE (node) == INTEGER_TYPE)
574 pp_string (buffer, (TYPE_UNSIGNED (node)
575 ? "<unnamed-unsigned:"
576 : "<unnamed-signed:"));
577 pp_decimal_int (buffer, TYPE_PRECISION (node));
578 pp_string (buffer, ">");
581 pp_string (buffer, "<unnamed type>");
588 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
590 if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
592 tree fnode = TREE_TYPE (node);
594 dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
596 pp_character (buffer, '(');
597 pp_string (buffer, str);
598 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
599 dump_decl_name (buffer, TYPE_NAME (node), flags);
601 pp_printf (buffer, "<T%x>", TYPE_UID (node));
603 pp_character (buffer, ')');
604 dump_function_declaration (buffer, fnode, spc, flags);
608 unsigned int quals = TYPE_QUALS (node);
610 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
612 pp_string (buffer, str);
614 if (quals & TYPE_QUAL_CONST)
615 pp_string (buffer, " const");
616 else if (quals & TYPE_QUAL_VOLATILE)
617 pp_string (buffer, "volatile");
618 else if (quals & TYPE_QUAL_RESTRICT)
619 pp_string (buffer, " restrict");
621 if (TYPE_REF_CAN_ALIAS_ALL (node))
622 pp_string (buffer, " {ref-all}");
631 dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
632 pp_string (buffer, "::");
637 const char *sep = "";
640 pp_string (buffer, "MEM[");
642 tmp = TMR_SYMBOL (node);
645 pp_string (buffer, sep);
647 pp_string (buffer, "symbol: ");
648 dump_generic_node (buffer, tmp, spc, flags, false);
650 tmp = TMR_BASE (node);
653 pp_string (buffer, sep);
655 pp_string (buffer, "base: ");
656 dump_generic_node (buffer, tmp, spc, flags, false);
658 tmp = TMR_INDEX (node);
661 pp_string (buffer, sep);
663 pp_string (buffer, "index: ");
664 dump_generic_node (buffer, tmp, spc, flags, false);
666 tmp = TMR_STEP (node);
669 pp_string (buffer, sep);
671 pp_string (buffer, "step: ");
672 dump_generic_node (buffer, tmp, spc, flags, false);
674 tmp = TMR_OFFSET (node);
677 pp_string (buffer, sep);
679 pp_string (buffer, "offset: ");
680 dump_generic_node (buffer, tmp, spc, flags, false);
682 pp_string (buffer, "]");
683 if (flags & TDF_DETAILS)
685 pp_string (buffer, "{");
686 dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,
688 pp_string (buffer, "}");
697 /* Print the innermost component type. */
698 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
699 tmp = TREE_TYPE (tmp))
701 dump_generic_node (buffer, tmp, spc, flags, false);
703 /* Print the dimensions. */
704 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
705 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
711 case QUAL_UNION_TYPE:
712 /* Print the name of the structure. */
713 if (TREE_CODE (node) == RECORD_TYPE)
714 pp_string (buffer, "struct ");
715 else if (TREE_CODE (node) == UNION_TYPE)
716 pp_string (buffer, "union ");
718 if (TYPE_NAME (node))
719 dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
721 print_struct_decl (buffer, node, spc, flags);
729 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
731 /* In the case of a pointer, one may want to divide by the
732 size of the pointed-to type. Unfortunately, this not
733 straightforward. The C front-end maps expressions
738 in such a way that the two INTEGER_CST nodes for "5" have
739 different values but identical types. In the latter
740 case, the 5 is multiplied by sizeof (int) in c-common.c
741 (pointer_int_sum) to convert it to a byte address, and
742 yet the type of the node is left unchanged. Argh. What
743 is consistent though is that the number value corresponds
744 to bytes (UNITS) offset.
746 NB: Neither of the following divisors can be trivially
747 used to recover the original literal:
749 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
750 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
751 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
752 pp_string (buffer, "B"); /* pseudo-unit */
754 else if (! host_integerp (node, 0))
757 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
758 HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);
760 if (tree_int_cst_sgn (val) < 0)
762 pp_character (buffer, '-');
766 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
768 sprintf (pp_buffer (buffer)->digit_buffer,
769 HOST_WIDE_INT_PRINT_DOUBLE_HEX, high, low);
770 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
773 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
777 /* Code copied from print_node. */
780 if (TREE_OVERFLOW (node))
781 pp_string (buffer, " overflow");
783 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
784 d = TREE_REAL_CST (node);
785 if (REAL_VALUE_ISINF (d))
786 pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
787 else if (REAL_VALUE_ISNAN (d))
788 pp_string (buffer, " Nan");
792 real_to_decimal (string, &d, sizeof (string), 0, 1);
793 pp_string (buffer, string);
798 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
799 pp_string (buffer, "0x");
800 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
801 output_formatted_integer (buffer, "%02x", *p++);
808 pp_string (buffer, "__complex__ (");
809 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
810 pp_string (buffer, ", ");
811 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
812 pp_string (buffer, ")");
816 pp_string (buffer, "\"");
817 pretty_print_string (buffer, TREE_STRING_POINTER (node));
818 pp_string (buffer, "\"");
824 pp_string (buffer, "{ ");
825 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
827 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
828 if (TREE_CHAIN (elt))
829 pp_string (buffer, ", ");
831 pp_string (buffer, " }");
840 dump_decl_name (buffer, node, flags);
844 if (DECL_NAME (node))
845 dump_decl_name (buffer, node, flags);
846 else if (LABEL_DECL_UID (node) != -1)
847 pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
848 LABEL_DECL_UID (node));
850 pp_printf (buffer, "<D%u>", DECL_UID (node));
854 if (DECL_IS_BUILTIN (node))
856 /* Don't print the declaration of built-in types. */
859 if (DECL_NAME (node))
860 dump_decl_name (buffer, node, flags);
863 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
864 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
865 && TYPE_METHODS (TREE_TYPE (node)))
867 /* The type is a c++ class: all structures have at least
869 pp_string (buffer, "class ");
870 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
875 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
876 ? "union" : "struct "));
877 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
882 case SYMBOL_MEMORY_TAG:
883 case NAME_MEMORY_TAG:
884 case STRUCT_FIELD_TAG:
889 case MEMORY_PARTITION_TAG:
890 dump_decl_name (buffer, node, flags);
894 pp_string (buffer, "<retval>");
898 op0 = TREE_OPERAND (node, 0);
900 if (TREE_CODE (op0) == INDIRECT_REF)
902 op0 = TREE_OPERAND (op0, 0);
905 if (op_prio (op0) < op_prio (node))
906 pp_character (buffer, '(');
907 dump_generic_node (buffer, op0, spc, flags, false);
908 if (op_prio (op0) < op_prio (node))
909 pp_character (buffer, ')');
910 pp_string (buffer, str);
911 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
913 if (TREE_CODE (op0) != VALUE_HANDLE)
915 op0 = component_ref_field_offset (node);
916 if (op0 && TREE_CODE (op0) != INTEGER_CST)
918 pp_string (buffer, "{off: ");
919 dump_generic_node (buffer, op0, spc, flags, false);
920 pp_character (buffer, '}');
926 pp_string (buffer, "BIT_FIELD_REF <");
927 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
928 pp_string (buffer, ", ");
929 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
930 pp_string (buffer, ", ");
931 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
932 pp_string (buffer, ">");
936 case ARRAY_RANGE_REF:
937 op0 = TREE_OPERAND (node, 0);
938 if (op_prio (op0) < op_prio (node))
939 pp_character (buffer, '(');
940 dump_generic_node (buffer, op0, spc, flags, false);
941 if (op_prio (op0) < op_prio (node))
942 pp_character (buffer, ')');
943 pp_character (buffer, '[');
944 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
945 if (TREE_CODE (node) == ARRAY_RANGE_REF)
946 pp_string (buffer, " ...");
947 pp_character (buffer, ']');
949 op0 = array_ref_low_bound (node);
950 op1 = array_ref_element_size (node);
952 if (!integer_zerop (op0)
953 || TREE_OPERAND (node, 2)
954 || TREE_OPERAND (node, 3))
956 pp_string (buffer, "{lb: ");
957 dump_generic_node (buffer, op0, spc, flags, false);
958 pp_string (buffer, " sz: ");
959 dump_generic_node (buffer, op1, spc, flags, false);
960 pp_character (buffer, '}');
966 unsigned HOST_WIDE_INT ix;
968 bool is_struct_init = FALSE;
969 pp_character (buffer, '{');
970 if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
971 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
972 is_struct_init = TRUE;
973 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
975 if (field && is_struct_init)
977 pp_character (buffer, '.');
978 dump_generic_node (buffer, field, spc, flags, false);
979 pp_string (buffer, "=");
981 if (val && TREE_CODE (val) == ADDR_EXPR)
982 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
983 val = TREE_OPERAND (val, 0);
984 if (val && TREE_CODE (val) == FUNCTION_DECL)
985 dump_decl_name (buffer, val, flags);
987 dump_generic_node (buffer, val, spc, flags, false);
988 if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
990 pp_character (buffer, ',');
994 pp_character (buffer, '}');
1001 if (flags & TDF_SLIM)
1003 pp_string (buffer, "<COMPOUND_EXPR>");
1007 dump_generic_node (buffer, TREE_OPERAND (node, 0),
1008 spc, flags, !(flags & TDF_SLIM));
1009 if (flags & TDF_SLIM)
1010 newline_and_indent (buffer, spc);
1013 pp_character (buffer, ',');
1017 for (tp = &TREE_OPERAND (node, 1);
1018 TREE_CODE (*tp) == COMPOUND_EXPR;
1019 tp = &TREE_OPERAND (*tp, 1))
1021 dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
1022 spc, flags, !(flags & TDF_SLIM));
1023 if (flags & TDF_SLIM)
1024 newline_and_indent (buffer, spc);
1027 pp_character (buffer, ',');
1032 dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
1036 case STATEMENT_LIST:
1038 tree_stmt_iterator si;
1041 if (flags & TDF_SLIM)
1043 pp_string (buffer, "<STATEMENT_LIST>");
1047 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1050 newline_and_indent (buffer, spc);
1053 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
1059 case GIMPLE_MODIFY_STMT:
1061 dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 0), spc, flags,
1064 pp_character (buffer, '=');
1065 if (TREE_CODE (node) == GIMPLE_MODIFY_STMT
1066 && MOVE_NONTEMPORAL (node))
1067 pp_string (buffer, "{nt}");
1069 dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
1074 pp_string (buffer, "TARGET_EXPR <");
1075 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1076 pp_character (buffer, ',');
1078 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
1079 pp_character (buffer, '>');
1083 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1088 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1090 pp_string (buffer, "if (");
1091 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1092 pp_character (buffer, ')');
1093 /* The lowered cond_exprs should always be printed in full. */
1094 if (COND_EXPR_THEN (node)
1095 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1096 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1097 && COND_EXPR_ELSE (node)
1098 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1099 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1102 dump_generic_node (buffer, COND_EXPR_THEN (node),
1104 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1106 pp_string (buffer, " else ");
1107 dump_generic_node (buffer, COND_EXPR_ELSE (node),
1111 else if (!(flags & TDF_SLIM))
1113 /* Output COND_EXPR_THEN. */
1114 if (COND_EXPR_THEN (node))
1116 newline_and_indent (buffer, spc+2);
1117 pp_character (buffer, '{');
1118 newline_and_indent (buffer, spc+4);
1119 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1121 newline_and_indent (buffer, spc+2);
1122 pp_character (buffer, '}');
1125 /* Output COND_EXPR_ELSE. */
1126 if (COND_EXPR_ELSE (node)
1127 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1129 newline_and_indent (buffer, spc);
1130 pp_string (buffer, "else");
1131 newline_and_indent (buffer, spc+2);
1132 pp_character (buffer, '{');
1133 newline_and_indent (buffer, spc+4);
1134 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1136 newline_and_indent (buffer, spc+2);
1137 pp_character (buffer, '}');
1144 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1146 pp_character (buffer, '?');
1148 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1150 pp_character (buffer, ':');
1152 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1157 pp_character (buffer, '{');
1158 if (!(flags & TDF_SLIM))
1160 if (BIND_EXPR_VARS (node))
1162 pp_newline (buffer);
1164 for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
1166 print_declaration (buffer, op0, spc+2, flags);
1167 pp_newline (buffer);
1171 newline_and_indent (buffer, spc+2);
1172 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1173 newline_and_indent (buffer, spc);
1174 pp_character (buffer, '}');
1180 print_call_name (buffer, node);
1182 /* Print parameters. */
1184 pp_character (buffer, '(');
1187 call_expr_arg_iterator iter;
1188 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
1190 dump_generic_node (buffer, arg, spc, flags, false);
1191 if (more_call_expr_args_p (&iter))
1193 pp_character (buffer, ',');
1198 pp_character (buffer, ')');
1200 op1 = CALL_EXPR_STATIC_CHAIN (node);
1203 pp_string (buffer, " [static-chain: ");
1204 dump_generic_node (buffer, op1, spc, flags, false);
1205 pp_character (buffer, ']');
1208 if (CALL_EXPR_RETURN_SLOT_OPT (node))
1209 pp_string (buffer, " [return slot optimization]");
1210 if (CALL_EXPR_TAILCALL (node))
1211 pp_string (buffer, " [tail call]");
1214 case WITH_CLEANUP_EXPR:
1218 case CLEANUP_POINT_EXPR:
1219 pp_string (buffer, "<<cleanup_point ");
1220 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1221 pp_string (buffer, ">>");
1224 case PLACEHOLDER_EXPR:
1225 pp_string (buffer, "<PLACEHOLDER_EXPR ");
1226 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1227 pp_character (buffer, '>');
1230 /* Binary arithmetic and logic expressions. */
1231 case WIDEN_SUM_EXPR:
1232 case WIDEN_MULT_EXPR:
1235 case POINTER_PLUS_EXPR:
1237 case TRUNC_DIV_EXPR:
1239 case FLOOR_DIV_EXPR:
1240 case ROUND_DIV_EXPR:
1241 case TRUNC_MOD_EXPR:
1243 case FLOOR_MOD_EXPR:
1244 case ROUND_MOD_EXPR:
1246 case EXACT_DIV_EXPR:
1251 case VEC_LSHIFT_EXPR:
1252 case VEC_RSHIFT_EXPR:
1256 case TRUTH_ANDIF_EXPR:
1257 case TRUTH_ORIF_EXPR:
1258 case TRUTH_AND_EXPR:
1260 case TRUTH_XOR_EXPR:
1274 case UNORDERED_EXPR:
1276 const char *op = op_symbol (node);
1277 op0 = TREE_OPERAND (node, 0);
1278 op1 = TREE_OPERAND (node, 1);
1280 /* When the operands are expressions with less priority,
1281 keep semantics of the tree representation. */
1282 if (op_prio (op0) <= op_prio (node))
1284 pp_character (buffer, '(');
1285 dump_generic_node (buffer, op0, spc, flags, false);
1286 pp_character (buffer, ')');
1289 dump_generic_node (buffer, op0, spc, flags, false);
1292 pp_string (buffer, op);
1295 /* When the operands are expressions with less priority,
1296 keep semantics of the tree representation. */
1297 if (op_prio (op1) <= op_prio (node))
1299 pp_character (buffer, '(');
1300 dump_generic_node (buffer, op1, spc, flags, false);
1301 pp_character (buffer, ')');
1304 dump_generic_node (buffer, op1, spc, flags, false);
1308 /* Unary arithmetic and logic expressions. */
1311 case TRUTH_NOT_EXPR:
1313 case PREDECREMENT_EXPR:
1314 case PREINCREMENT_EXPR:
1315 case ALIGN_INDIRECT_REF:
1316 case MISALIGNED_INDIRECT_REF:
1318 if (TREE_CODE (node) == ADDR_EXPR
1319 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1320 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1321 ; /* Do not output '&' for strings and function pointers. */
1323 pp_string (buffer, op_symbol (node));
1325 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1327 pp_character (buffer, '(');
1328 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1329 pp_character (buffer, ')');
1332 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1334 if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1336 pp_string (buffer, "{misalignment: ");
1337 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1338 pp_character (buffer, '}');
1342 case POSTDECREMENT_EXPR:
1343 case POSTINCREMENT_EXPR:
1344 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1346 pp_character (buffer, '(');
1347 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1348 pp_character (buffer, ')');
1351 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1352 pp_string (buffer, op_symbol (node));
1356 pp_string (buffer, "MIN_EXPR <");
1357 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1358 pp_string (buffer, ", ");
1359 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1360 pp_character (buffer, '>');
1364 pp_string (buffer, "MAX_EXPR <");
1365 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1366 pp_string (buffer, ", ");
1367 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1368 pp_character (buffer, '>');
1372 pp_string (buffer, "ABS_EXPR <");
1373 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1374 pp_character (buffer, '>');
1381 case FIX_TRUNC_EXPR:
1385 type = TREE_TYPE (node);
1386 op0 = TREE_OPERAND (node, 0);
1387 if (type != TREE_TYPE (op0))
1389 pp_character (buffer, '(');
1390 dump_generic_node (buffer, type, spc, flags, false);
1391 pp_string (buffer, ") ");
1393 if (op_prio (op0) < op_prio (node))
1394 pp_character (buffer, '(');
1395 dump_generic_node (buffer, op0, spc, flags, false);
1396 if (op_prio (op0) < op_prio (node))
1397 pp_character (buffer, ')');
1400 case VIEW_CONVERT_EXPR:
1401 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1402 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1403 pp_string (buffer, ">(");
1404 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1405 pp_character (buffer, ')');
1408 case NON_LVALUE_EXPR:
1409 pp_string (buffer, "NON_LVALUE_EXPR <");
1410 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1411 pp_character (buffer, '>');
1415 pp_string (buffer, "SAVE_EXPR <");
1416 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1417 pp_character (buffer, '>');
1421 pp_string (buffer, "COMPLEX_EXPR <");
1422 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1423 pp_string (buffer, ", ");
1424 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1425 pp_string (buffer, ">");
1429 pp_string (buffer, "CONJ_EXPR <");
1430 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1431 pp_string (buffer, ">");
1435 pp_string (buffer, "REALPART_EXPR <");
1436 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1437 pp_string (buffer, ">");
1441 pp_string (buffer, "IMAGPART_EXPR <");
1442 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1443 pp_string (buffer, ">");
1447 pp_string (buffer, "VA_ARG_EXPR <");
1448 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1449 pp_string (buffer, ">");
1452 case TRY_FINALLY_EXPR:
1453 case TRY_CATCH_EXPR:
1454 pp_string (buffer, "try");
1455 newline_and_indent (buffer, spc+2);
1456 pp_string (buffer, "{");
1457 newline_and_indent (buffer, spc+4);
1458 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1459 newline_and_indent (buffer, spc+2);
1460 pp_string (buffer, "}");
1461 newline_and_indent (buffer, spc);
1463 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1464 newline_and_indent (buffer, spc+2);
1465 pp_string (buffer, "{");
1466 newline_and_indent (buffer, spc+4);
1467 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1468 newline_and_indent (buffer, spc+2);
1469 pp_string (buffer, "}");
1474 pp_string (buffer, "catch (");
1475 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1476 pp_string (buffer, ")");
1477 newline_and_indent (buffer, spc+2);
1478 pp_string (buffer, "{");
1479 newline_and_indent (buffer, spc+4);
1480 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1481 newline_and_indent (buffer, spc+2);
1482 pp_string (buffer, "}");
1486 case EH_FILTER_EXPR:
1487 pp_string (buffer, "<<<eh_filter (");
1488 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1489 pp_string (buffer, ")>>>");
1490 newline_and_indent (buffer, spc+2);
1491 pp_string (buffer, "{");
1492 newline_and_indent (buffer, spc+4);
1493 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1494 newline_and_indent (buffer, spc+2);
1495 pp_string (buffer, "}");
1499 case CHANGE_DYNAMIC_TYPE_EXPR:
1500 pp_string (buffer, "<<<change_dynamic_type (");
1501 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_NEW_TYPE (node), spc + 2,
1503 pp_string (buffer, ") ");
1504 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_LOCATION (node), spc + 2,
1506 pp_string (buffer, ")>>>");
1511 op0 = TREE_OPERAND (node, 0);
1512 /* If this is for break or continue, don't bother printing it. */
1513 if (DECL_NAME (op0))
1515 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1516 if (strcmp (name, "break") == 0
1517 || strcmp (name, "continue") == 0)
1520 dump_generic_node (buffer, op0, spc, flags, false);
1521 pp_character (buffer, ':');
1522 if (DECL_NONLOCAL (op0))
1523 pp_string (buffer, " [non-local]");
1527 pp_string (buffer, "<<<exception object>>>");
1531 pp_string (buffer, "<<<filter object>>>");
1535 pp_string (buffer, "while (1)");
1536 if (!(flags & TDF_SLIM))
1538 newline_and_indent (buffer, spc+2);
1539 pp_character (buffer, '{');
1540 newline_and_indent (buffer, spc+4);
1541 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1542 newline_and_indent (buffer, spc+2);
1543 pp_character (buffer, '}');
1549 pp_string (buffer, "return");
1550 op0 = TREE_OPERAND (node, 0);
1554 if (TREE_CODE (op0) == MODIFY_EXPR
1555 || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
1556 dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
1559 dump_generic_node (buffer, op0, spc, flags, false);
1564 pp_string (buffer, "if (");
1565 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1566 pp_string (buffer, ") break");
1570 pp_string (buffer, "switch (");
1571 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1572 pp_character (buffer, ')');
1573 if (!(flags & TDF_SLIM))
1575 newline_and_indent (buffer, spc+2);
1576 pp_character (buffer, '{');
1577 if (SWITCH_BODY (node))
1579 newline_and_indent (buffer, spc+4);
1580 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1585 tree vec = SWITCH_LABELS (node);
1586 size_t i, n = TREE_VEC_LENGTH (vec);
1587 for (i = 0; i < n; ++i)
1589 tree elt = TREE_VEC_ELT (vec, i);
1590 newline_and_indent (buffer, spc+4);
1593 dump_generic_node (buffer, elt, spc+4, flags, false);
1594 pp_string (buffer, " goto ");
1595 dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1597 pp_semicolon (buffer);
1600 pp_string (buffer, "case ???: goto ???;");
1603 newline_and_indent (buffer, spc+2);
1604 pp_character (buffer, '}');
1610 op0 = GOTO_DESTINATION (node);
1611 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1613 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1614 if (strcmp (name, "break") == 0
1615 || strcmp (name, "continue") == 0)
1617 pp_string (buffer, name);
1621 pp_string (buffer, "goto ");
1622 dump_generic_node (buffer, op0, spc, flags, false);
1626 pp_string (buffer, "resx ");
1627 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1631 pp_string (buffer, "__asm__");
1632 if (ASM_VOLATILE_P (node))
1633 pp_string (buffer, " __volatile__");
1634 pp_character (buffer, '(');
1635 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1636 pp_character (buffer, ':');
1637 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1638 pp_character (buffer, ':');
1639 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1640 if (ASM_CLOBBERS (node))
1642 pp_character (buffer, ':');
1643 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1645 pp_string (buffer, ")");
1648 case CASE_LABEL_EXPR:
1649 if (CASE_LOW (node) && CASE_HIGH (node))
1651 pp_string (buffer, "case ");
1652 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1653 pp_string (buffer, " ... ");
1654 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1656 else if (CASE_LOW (node))
1658 pp_string (buffer, "case ");
1659 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1662 pp_string (buffer, "default ");
1663 pp_character (buffer, ':');
1667 pp_string (buffer, "OBJ_TYPE_REF(");
1668 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1669 pp_character (buffer, ';');
1670 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1671 pp_character (buffer, '-');
1672 pp_character (buffer, '>');
1673 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1674 pp_character (buffer, ')');
1681 dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1682 pp_string (buffer, " = PHI <");
1683 for (i = 0; i < PHI_NUM_ARGS (node); i++)
1685 dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1686 pp_string (buffer, "(");
1687 pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1688 pp_string (buffer, ")");
1689 if (i < PHI_NUM_ARGS (node) - 1)
1690 pp_string (buffer, ", ");
1692 pp_string (buffer, ">");
1694 if (stmt_references_memory_p (node) && (flags & TDF_MEMSYMS))
1695 dump_symbols (buffer, STORED_SYMS (node), flags);
1700 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1701 pp_string (buffer, "_");
1702 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1703 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1704 pp_string (buffer, "(ab)");
1705 else if (SSA_NAME_IS_DEFAULT_DEF (node))
1706 pp_string (buffer, "(D)");
1709 case WITH_SIZE_EXPR:
1710 pp_string (buffer, "WITH_SIZE_EXPR <");
1711 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1712 pp_string (buffer, ", ");
1713 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1714 pp_string (buffer, ">");
1718 pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1722 pp_string (buffer, "ASSERT_EXPR <");
1723 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1724 pp_string (buffer, ", ");
1725 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1726 pp_string (buffer, ">");
1730 pp_string (buffer, "scev_known");
1733 case SCEV_NOT_KNOWN:
1734 pp_string (buffer, "scev_not_known");
1737 case POLYNOMIAL_CHREC:
1738 pp_string (buffer, "{");
1739 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1740 pp_string (buffer, ", +, ");
1741 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1742 pp_string (buffer, "}_");
1743 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1747 case REALIGN_LOAD_EXPR:
1748 pp_string (buffer, "REALIGN_LOAD <");
1749 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1750 pp_string (buffer, ", ");
1751 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1752 pp_string (buffer, ", ");
1753 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1754 pp_string (buffer, ">");
1758 pp_string (buffer, " VEC_COND_EXPR < ");
1759 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1760 pp_string (buffer, " , ");
1761 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1762 pp_string (buffer, " , ");
1763 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1764 pp_string (buffer, " > ");
1768 pp_string (buffer, " DOT_PROD_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, ", ");
1773 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1774 pp_string (buffer, " > ");
1778 pp_string (buffer, "#pragma omp parallel");
1779 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
1780 if (OMP_PARALLEL_FN (node))
1782 pp_string (buffer, " [child fn: ");
1783 dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);
1785 pp_string (buffer, " (");
1787 if (OMP_PARALLEL_DATA_ARG (node))
1788 dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,
1791 pp_string (buffer, "???");
1793 pp_string (buffer, ")]");
1797 if (!(flags & TDF_SLIM) && OMP_BODY (node))
1799 newline_and_indent (buffer, spc + 2);
1800 pp_character (buffer, '{');
1801 newline_and_indent (buffer, spc + 4);
1802 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
1803 newline_and_indent (buffer, spc + 2);
1804 pp_character (buffer, '}');
1810 pp_string (buffer, "#pragma omp for");
1811 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
1813 if (!(flags & TDF_SLIM))
1815 if (OMP_FOR_PRE_BODY (node))
1817 newline_and_indent (buffer, spc + 2);
1818 pp_character (buffer, '{');
1820 newline_and_indent (buffer, spc);
1821 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
1824 newline_and_indent (buffer, spc);
1825 pp_string (buffer, "for (");
1826 dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);
1827 pp_string (buffer, "; ");
1828 dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);
1829 pp_string (buffer, "; ");
1830 dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);
1831 pp_string (buffer, ")");
1832 if (OMP_FOR_BODY (node))
1834 newline_and_indent (buffer, spc + 2);
1835 pp_character (buffer, '{');
1836 newline_and_indent (buffer, spc + 4);
1837 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
1839 newline_and_indent (buffer, spc + 2);
1840 pp_character (buffer, '}');
1842 if (OMP_FOR_PRE_BODY (node))
1845 newline_and_indent (buffer, spc + 2);
1846 pp_character (buffer, '}');
1853 pp_string (buffer, "#pragma omp sections");
1854 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
1858 pp_string (buffer, "#pragma omp section");
1862 pp_string (buffer, "#pragma omp master");
1866 pp_string (buffer, "#pragma omp ordered");
1870 pp_string (buffer, "#pragma omp critical");
1871 if (OMP_CRITICAL_NAME (node))
1874 pp_character (buffer, '(');
1875 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
1877 pp_character (buffer, ')');
1882 pp_string (buffer, "#pragma omp atomic");
1883 newline_and_indent (buffer, spc + 2);
1884 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1886 pp_character (buffer, '=');
1888 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1892 pp_string (buffer, "#pragma omp single");
1893 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
1897 pp_string (buffer, "OMP_RETURN");
1898 if (OMP_RETURN_NOWAIT (node))
1899 pp_string (buffer, " [nowait]");
1904 pp_string (buffer, "OMP_CONTINUE");
1909 dump_omp_clause (buffer, node, spc, flags);
1913 case REDUC_MAX_EXPR:
1914 pp_string (buffer, " REDUC_MAX_EXPR < ");
1915 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1916 pp_string (buffer, " > ");
1919 case REDUC_MIN_EXPR:
1920 pp_string (buffer, " REDUC_MIN_EXPR < ");
1921 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1922 pp_string (buffer, " > ");
1925 case REDUC_PLUS_EXPR:
1926 pp_string (buffer, " REDUC_PLUS_EXPR < ");
1927 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1928 pp_string (buffer, " > ");
1931 case VEC_WIDEN_MULT_HI_EXPR:
1932 pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
1933 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1934 pp_string (buffer, ", ");
1935 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1936 pp_string (buffer, " > ");
1939 case VEC_WIDEN_MULT_LO_EXPR:
1940 pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
1941 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1942 pp_string (buffer, ", ");
1943 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1944 pp_string (buffer, " > ");
1947 case VEC_UNPACK_HI_EXPR:
1948 pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
1949 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1950 pp_string (buffer, " > ");
1953 case VEC_UNPACK_LO_EXPR:
1954 pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
1955 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1956 pp_string (buffer, " > ");
1959 case VEC_UNPACK_FLOAT_HI_EXPR:
1960 pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");
1961 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1962 pp_string (buffer, " > ");
1965 case VEC_UNPACK_FLOAT_LO_EXPR:
1966 pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");
1967 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1968 pp_string (buffer, " > ");
1971 case VEC_PACK_TRUNC_EXPR:
1972 pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
1973 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1974 pp_string (buffer, ", ");
1975 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1976 pp_string (buffer, " > ");
1979 case VEC_PACK_SAT_EXPR:
1980 pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
1981 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1982 pp_string (buffer, ", ");
1983 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1984 pp_string (buffer, " > ");
1987 case VEC_PACK_FIX_TRUNC_EXPR:
1988 pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");
1989 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1990 pp_string (buffer, ", ");
1991 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1992 pp_string (buffer, " > ");
1998 pp_string (buffer, "BLOCK");
2000 if (BLOCK_ABSTRACT (node))
2001 pp_string (buffer, " [abstract]");
2003 if (TREE_ASM_WRITTEN (node))
2004 pp_string (buffer, " [written]");
2006 newline_and_indent (buffer, spc + 2);
2008 if (BLOCK_SUPERCONTEXT (node))
2010 pp_string (buffer, "SUPERCONTEXT: ");
2011 if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
2012 pp_printf (buffer, "BLOCK %p",
2013 (void *)BLOCK_SUPERCONTEXT (node));
2015 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
2017 newline_and_indent (buffer, spc + 2);
2020 if (BLOCK_SUBBLOCKS (node))
2022 pp_string (buffer, "SUBBLOCKS: ");
2023 for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
2024 pp_printf (buffer, "%p ", (void *)t);
2025 newline_and_indent (buffer, spc + 2);
2028 if (BLOCK_VARS (node))
2030 pp_string (buffer, "VARS: ");
2031 for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
2033 dump_generic_node (buffer, t, 0, flags, false);
2034 pp_string (buffer, " ");
2036 newline_and_indent (buffer, spc + 2);
2039 if (BLOCK_ABSTRACT_ORIGIN (node))
2041 pp_string (buffer, "ABSTRACT_ORIGIN: ");
2042 if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
2043 pp_printf (buffer, "BLOCK %p",
2044 (void *)BLOCK_ABSTRACT_ORIGIN (node));
2046 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
2048 newline_and_indent (buffer, spc + 2);
2053 case VEC_EXTRACT_EVEN_EXPR:
2054 pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
2055 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2056 pp_string (buffer, ", ");
2057 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2058 pp_string (buffer, " > ");
2061 case VEC_EXTRACT_ODD_EXPR:
2062 pp_string (buffer, " VEC_EXTRACT_ODD_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_INTERLEAVE_HIGH_EXPR:
2070 pp_string (buffer, " VEC_INTERLEAVE_HIGH_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_INTERLEAVE_LOW_EXPR:
2078 pp_string (buffer, " VEC_INTERLEAVE_LOW_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, " > ");
2089 if (is_stmt && is_expr)
2090 pp_semicolon (buffer);
2092 /* If we're building a diagnostic, the formatted text will be written
2093 into BUFFER's stream by the caller; otherwise, write it now. */
2094 if (!(flags & TDF_DIAGNOSTIC))
2095 pp_write_text_to_stream (buffer);
2100 /* Print the declaration of a variable. */
2103 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2107 if (TREE_CODE (t) == TYPE_DECL)
2108 pp_string (buffer, "typedef ");
2110 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2111 pp_string (buffer, "register ");
2113 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2114 pp_string (buffer, "extern ");
2115 else if (TREE_STATIC (t))
2116 pp_string (buffer, "static ");
2118 /* Print the type and name. */
2119 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2123 /* Print array's type. */
2124 tmp = TREE_TYPE (t);
2125 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2126 tmp = TREE_TYPE (tmp);
2127 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2129 /* Print variable's name. */
2131 dump_generic_node (buffer, t, spc, flags, false);
2133 /* Print the dimensions. */
2134 tmp = TREE_TYPE (t);
2135 while (TREE_CODE (tmp) == ARRAY_TYPE)
2137 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
2138 tmp = TREE_TYPE (tmp);
2141 else if (TREE_CODE (t) == FUNCTION_DECL)
2143 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2145 dump_decl_name (buffer, t, flags);
2146 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2150 /* Print type declaration. */
2151 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2153 /* Print variable's name. */
2155 dump_generic_node (buffer, t, spc, flags, false);
2158 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2160 pp_string (buffer, " __asm__ ");
2161 pp_character (buffer, '(');
2162 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2163 pp_character (buffer, ')');
2166 /* The initial value of a function serves to determine wether the function
2167 is declared or defined. So the following does not apply to function
2169 if (TREE_CODE (t) != FUNCTION_DECL)
2171 /* Print the initial value. */
2172 if (DECL_INITIAL (t))
2175 pp_character (buffer, '=');
2177 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2181 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2183 pp_string (buffer, " [value-expr: ");
2184 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2185 pp_character (buffer, ']');
2188 pp_character (buffer, ';');
2192 /* Prints a structure: name, fields, and methods.
2193 FIXME: Still incomplete. */
2196 print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
2198 /* Print the name of the structure. */
2199 if (TYPE_NAME (node))
2202 if (TREE_CODE (node) == RECORD_TYPE)
2203 pp_string (buffer, "struct ");
2204 else if ((TREE_CODE (node) == UNION_TYPE
2205 || TREE_CODE (node) == QUAL_UNION_TYPE))
2206 pp_string (buffer, "union ");
2208 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2211 /* Print the contents of the structure. */
2212 pp_newline (buffer);
2214 pp_character (buffer, '{');
2215 pp_newline (buffer);
2217 /* Print the fields of the structure. */
2220 tmp = TYPE_FIELDS (node);
2223 /* Avoid to print recursively the structure. */
2224 /* FIXME : Not implemented correctly...,
2225 what about the case when we have a cycle in the contain graph? ...
2226 Maybe this could be solved by looking at the scope in which the
2227 structure was declared. */
2228 if (TREE_TYPE (tmp) != node
2229 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
2230 && TREE_TYPE (TREE_TYPE (tmp)) != node))
2232 print_declaration (buffer, tmp, spc+2, flags);
2233 pp_newline (buffer);
2235 tmp = TREE_CHAIN (tmp);
2239 pp_character (buffer, '}');
2242 /* Return the priority of the operator OP.
2244 From lowest to highest precedence with either left-to-right (L-R)
2245 or right-to-left (R-L) associativity]:
2248 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2260 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2261 15 [L-R] fn() [] -> .
2263 unary +, - and * have higher precedence than the corresponding binary
2272 switch (TREE_CODE (op))
2280 case GIMPLE_MODIFY_STMT:
2288 case TRUTH_ORIF_EXPR:
2291 case TRUTH_AND_EXPR:
2292 case TRUTH_ANDIF_EXPR:
2299 case TRUTH_XOR_EXPR:
2316 case UNORDERED_EXPR:
2329 case WIDEN_SUM_EXPR:
2331 case POINTER_PLUS_EXPR:
2335 case VEC_WIDEN_MULT_HI_EXPR:
2336 case VEC_WIDEN_MULT_LO_EXPR:
2337 case WIDEN_MULT_EXPR:
2340 case TRUNC_DIV_EXPR:
2342 case FLOOR_DIV_EXPR:
2343 case ROUND_DIV_EXPR:
2345 case EXACT_DIV_EXPR:
2346 case TRUNC_MOD_EXPR:
2348 case FLOOR_MOD_EXPR:
2349 case ROUND_MOD_EXPR:
2352 case TRUTH_NOT_EXPR:
2354 case POSTINCREMENT_EXPR:
2355 case POSTDECREMENT_EXPR:
2356 case PREINCREMENT_EXPR:
2357 case PREDECREMENT_EXPR:
2359 case ALIGN_INDIRECT_REF:
2360 case MISALIGNED_INDIRECT_REF:
2366 case FIX_TRUNC_EXPR:
2372 case ARRAY_RANGE_REF:
2376 /* Special expressions. */
2382 case REDUC_MAX_EXPR:
2383 case REDUC_MIN_EXPR:
2384 case REDUC_PLUS_EXPR:
2385 case VEC_LSHIFT_EXPR:
2386 case VEC_RSHIFT_EXPR:
2387 case VEC_UNPACK_HI_EXPR:
2388 case VEC_UNPACK_LO_EXPR:
2389 case VEC_UNPACK_FLOAT_HI_EXPR:
2390 case VEC_UNPACK_FLOAT_LO_EXPR:
2391 case VEC_PACK_TRUNC_EXPR:
2392 case VEC_PACK_SAT_EXPR:
2396 case NON_LVALUE_EXPR:
2397 return op_prio (TREE_OPERAND (op, 0));
2400 /* Return an arbitrarily high precedence to avoid surrounding single
2401 VAR_DECLs in ()s. */
2407 /* Return the symbol associated with operator CODE. */
2410 op_symbol_code (enum tree_code code)
2415 case GIMPLE_MODIFY_STMT:
2419 case TRUTH_ORIF_EXPR:
2422 case TRUTH_AND_EXPR:
2423 case TRUTH_ANDIF_EXPR:
2429 case TRUTH_XOR_EXPR:
2439 case UNORDERED_EXPR:
2485 case VEC_LSHIFT_EXPR:
2488 case VEC_RSHIFT_EXPR:
2491 case POINTER_PLUS_EXPR:
2497 case REDUC_PLUS_EXPR:
2500 case WIDEN_SUM_EXPR:
2503 case WIDEN_MULT_EXPR:
2513 case TRUTH_NOT_EXPR:
2520 case ALIGN_INDIRECT_REF:
2523 case MISALIGNED_INDIRECT_REF:
2526 case TRUNC_DIV_EXPR:
2533 case FLOOR_DIV_EXPR:
2536 case ROUND_DIV_EXPR:
2539 case EXACT_DIV_EXPR:
2542 case TRUNC_MOD_EXPR:
2548 case FLOOR_MOD_EXPR:
2551 case ROUND_MOD_EXPR:
2554 case PREDECREMENT_EXPR:
2557 case PREINCREMENT_EXPR:
2560 case POSTDECREMENT_EXPR:
2563 case POSTINCREMENT_EXPR:
2573 return "<<< ??? >>>";
2577 /* Return the symbol associated with operator OP. */
2582 return op_symbol_code (TREE_CODE (op));
2585 /* Prints the name of a CALL_EXPR. */
2588 print_call_name (pretty_printer *buffer, tree node)
2592 gcc_assert (TREE_CODE (node) == CALL_EXPR);
2594 op0 = CALL_EXPR_FN (node);
2596 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2597 op0 = TREE_OPERAND (op0, 0);
2599 switch (TREE_CODE (op0))
2603 dump_function_name (buffer, op0);
2609 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2613 pp_string (buffer, "(");
2614 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2615 pp_string (buffer, ") ? ");
2616 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
2617 pp_string (buffer, " : ");
2618 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
2622 /* The function is a pointer contained in a structure. */
2623 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
2624 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2625 dump_function_name (buffer, TREE_OPERAND (op0, 1));
2627 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2629 We can have several levels of structures and a function
2630 pointer inside. This is not implemented yet... */
2635 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2636 dump_function_name (buffer, TREE_OPERAND (op0, 0));
2638 dump_generic_node (buffer, op0, 0, 0, false);
2643 dump_generic_node (buffer, op0, 0, 0, false);
2651 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2654 pretty_print_string (pretty_printer *buffer, const char *str)
2664 pp_string (buffer, "\\b");
2668 pp_string (buffer, "\\f");
2672 pp_string (buffer, "\\n");
2676 pp_string (buffer, "\\r");
2680 pp_string (buffer, "\\t");
2684 pp_string (buffer, "\\v");
2688 pp_string (buffer, "\\\\");
2692 pp_string (buffer, "\\\"");
2696 pp_string (buffer, "\\'");
2699 /* No need to handle \0; the loop terminates on \0. */
2702 pp_string (buffer, "\\1");
2706 pp_string (buffer, "\\2");
2710 pp_string (buffer, "\\3");
2714 pp_string (buffer, "\\4");
2718 pp_string (buffer, "\\5");
2722 pp_string (buffer, "\\6");
2726 pp_string (buffer, "\\7");
2730 pp_character (buffer, str[0]);
2738 maybe_init_pretty_print (FILE *file)
2742 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2743 pp_needs_newline (&buffer) = true;
2747 buffer.buffer->stream = file;
2751 newline_and_indent (pretty_printer *buffer, int spc)
2753 pp_newline (buffer);
2759 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2761 struct voptype_d *vdefs;
2762 struct voptype_d *vuses;
2765 if (!ssa_operands_active () || !stmt_references_memory_p (stmt))
2768 /* Even if the statement doesn't have virtual operators yet, it may
2769 contain symbol information (this happens before aliases have been
2771 if ((flags & TDF_MEMSYMS)
2772 && VUSE_OPS (stmt) == NULL
2773 && VDEF_OPS (stmt) == NULL)
2775 if (LOADED_SYMS (stmt))
2777 pp_string (buffer, "# LOADS: ");
2778 dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2779 newline_and_indent (buffer, spc);
2782 if (STORED_SYMS (stmt))
2784 pp_string (buffer, "# STORES: ");
2785 dump_symbols (buffer, STORED_SYMS (stmt), flags);
2786 newline_and_indent (buffer, spc);
2792 vuses = VUSE_OPS (stmt);
2795 pp_string (buffer, "# VUSE <");
2797 n = VUSE_NUM (vuses);
2798 for (i = 0; i < n; i++)
2800 dump_generic_node (buffer, VUSE_OP (vuses, i), spc + 2, flags, false);
2802 pp_string (buffer, ", ");
2805 pp_string (buffer, ">");
2807 if (flags & TDF_MEMSYMS)
2808 dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2810 newline_and_indent (buffer, spc);
2811 vuses = vuses->next;
2814 vdefs = VDEF_OPS (stmt);
2817 pp_string (buffer, "# ");
2818 dump_generic_node (buffer, VDEF_RESULT (vdefs), spc + 2, flags, false);
2819 pp_string (buffer, " = VDEF <");
2821 n = VDEF_NUM (vdefs);
2822 for (i = 0; i < n; i++)
2824 dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, 0);
2826 pp_string (buffer, ", ");
2829 pp_string (buffer, ">");
2831 if ((flags & TDF_MEMSYMS) && vdefs->next == NULL)
2832 dump_symbols (buffer, STORED_SYMS (stmt), flags);
2834 newline_and_indent (buffer, spc);
2835 vdefs = vdefs->next;
2840 /* Dumps basic block BB to FILE with details described by FLAGS and
2841 indented by INDENT spaces. */
2844 dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2846 maybe_init_pretty_print (file);
2847 dump_generic_bb_buff (&buffer, bb, indent, flags);
2851 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2852 spaces and details described by flags. */
2855 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2861 if (flags & TDF_BLOCKS)
2864 pp_string (buffer, "# BLOCK ");
2865 pp_decimal_int (buffer, bb->index);
2868 pp_string (buffer, " freq:");
2869 pp_decimal_int (buffer, bb->frequency);
2873 pp_string (buffer, " count:");
2874 pp_widest_integer (buffer, bb->count);
2877 if (flags & TDF_LINENO)
2879 block_stmt_iterator bsi;
2881 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2882 if (get_lineno (bsi_stmt (bsi)) != -1)
2884 pp_string (buffer, ", starting at line ");
2885 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2889 newline_and_indent (buffer, indent);
2891 pp_string (buffer, "# PRED:");
2892 pp_write_text_to_stream (buffer);
2893 FOR_EACH_EDGE (e, ei, bb->preds)
2894 if (flags & TDF_SLIM)
2896 pp_string (buffer, " ");
2897 if (e->src == ENTRY_BLOCK_PTR)
2898 pp_string (buffer, "ENTRY");
2900 pp_decimal_int (buffer, e->src->index);
2903 dump_edge_info (buffer->buffer->stream, e, 0);
2904 pp_newline (buffer);
2908 stmt = first_stmt (bb);
2909 if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
2911 INDENT (indent - 2);
2912 pp_string (buffer, "<bb ");
2913 pp_decimal_int (buffer, bb->index);
2914 pp_string (buffer, ">:");
2915 pp_newline (buffer);
2918 pp_write_text_to_stream (buffer);
2919 check_bb_profile (bb, buffer->buffer->stream);
2922 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2926 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
2932 pp_string (buffer, "# SUCC:");
2933 pp_write_text_to_stream (buffer);
2934 FOR_EACH_EDGE (e, ei, bb->succs)
2935 if (flags & TDF_SLIM)
2937 pp_string (buffer, " ");
2938 if (e->dest == EXIT_BLOCK_PTR)
2939 pp_string (buffer, "EXIT");
2941 pp_decimal_int (buffer, e->dest->index);
2944 dump_edge_info (buffer->buffer->stream, e, 1);
2945 pp_newline (buffer);
2948 /* Dump PHI nodes of basic block BB to BUFFER with details described
2949 by FLAGS and indented by INDENT spaces. */
2952 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
2954 tree phi = phi_nodes (bb);
2958 for (; phi; phi = PHI_CHAIN (phi))
2960 if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
2963 pp_string (buffer, "# ");
2964 dump_generic_node (buffer, phi, indent, flags, false);
2965 pp_newline (buffer);
2971 /* Dump jump to basic block BB that is represented implicitly in the cfg
2975 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
2979 stmt = first_stmt (bb);
2981 pp_string (buffer, "goto <bb ");
2982 pp_decimal_int (buffer, bb->index);
2983 pp_string (buffer, ">");
2984 if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
2986 pp_string (buffer, " (");
2987 dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
2988 pp_string (buffer, ")");
2990 pp_semicolon (buffer);
2993 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
2994 by INDENT spaces, with details given by FLAGS. */
2997 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
3004 stmt = last_stmt (bb);
3005 if (stmt && TREE_CODE (stmt) == COND_EXPR)
3007 edge true_edge, false_edge;
3009 /* When we are emitting the code or changing CFG, it is possible that
3010 the edges are not yet created. When we are using debug_bb in such
3011 a situation, we do not want it to crash. */
3012 if (EDGE_COUNT (bb->succs) != 2)
3014 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
3016 INDENT (indent + 2);
3017 pp_cfg_jump (buffer, true_edge->dest);
3018 newline_and_indent (buffer, indent);
3019 pp_string (buffer, "else");
3020 newline_and_indent (buffer, indent + 2);
3021 pp_cfg_jump (buffer, false_edge->dest);
3022 pp_newline (buffer);
3026 /* If there is a fallthru edge, we may need to add an artificial goto to the
3028 FOR_EACH_EDGE (e, ei, bb->succs)
3029 if (e->flags & EDGE_FALLTHRU)
3031 if (e && e->dest != bb->next_bb)
3035 if ((flags & TDF_LINENO)
3036 #ifdef USE_MAPPED_LOCATION
3037 && e->goto_locus != UNKNOWN_LOCATION
3043 expanded_location goto_xloc;
3044 #ifdef USE_MAPPED_LOCATION
3045 goto_xloc = expand_location (e->goto_locus);
3047 goto_xloc = *e->goto_locus;
3049 pp_character (buffer, '[');
3052 pp_string (buffer, goto_xloc.file);
3053 pp_string (buffer, " : ");
3055 pp_decimal_int (buffer, goto_xloc.line);
3056 pp_string (buffer, "] ");
3059 pp_cfg_jump (buffer, e->dest);
3060 pp_newline (buffer);
3064 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
3065 indented by INDENT spaces. */
3068 dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
3069 int indent, int flags)
3071 block_stmt_iterator bsi;
3073 int label_indent = indent - 2;
3075 if (label_indent < 0)
3078 dump_bb_header (buffer, bb, indent, flags);
3080 dump_phi_nodes (buffer, bb, indent, flags);
3082 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
3086 stmt = bsi_stmt (bsi);
3088 curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
3090 INDENT (curr_indent);
3091 dump_generic_node (buffer, stmt, curr_indent, flags, true);
3092 pp_newline (buffer);
3093 dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
3096 dump_implicit_edges (buffer, bb, indent, flags);
3098 if (flags & TDF_BLOCKS)
3099 dump_bb_end (buffer, bb, indent, flags);