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 2, 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 COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
25 #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 "value-prof.h"
38 /* Local functions, macros and variables. */
39 static int op_prio (tree);
40 static const char *op_symbol_1 (enum tree_code);
41 static const char *op_symbol (tree);
42 static void pretty_print_string (pretty_printer *, const char*);
43 static void print_call_name (pretty_printer *, tree);
44 static void newline_and_indent (pretty_printer *, int);
45 static void maybe_init_pretty_print (FILE *);
46 static void print_declaration (pretty_printer *, tree, int, int);
47 static void print_struct_decl (pretty_printer *, tree, int, int);
48 static void do_niy (pretty_printer *, tree);
49 static void dump_vops (pretty_printer *, tree, int, int);
50 static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
52 #define INDENT(SPACE) do { \
53 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
55 #define NIY do_niy(buffer,node)
57 #define PRINT_FUNCTION_NAME(NODE) pp_printf \
58 (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \
59 lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
60 lang_hooks.decl_printable_name (NODE, 1))
62 static pretty_printer buffer;
63 static int initialized = 0;
65 /* Try to print something for an unknown tree code. */
68 do_niy (pretty_printer *buffer, tree node)
72 pp_string (buffer, "<<< Unknown tree: ");
73 pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
77 len = TREE_OPERAND_LENGTH (node);
78 for (i = 0; i < len; ++i)
80 newline_and_indent (buffer, 2);
81 dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);
85 pp_string (buffer, " >>>\n");
89 debug_generic_expr (tree t)
91 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
92 fprintf (stderr, "\n");
96 debug_generic_stmt (tree t)
98 print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
99 fprintf (stderr, "\n");
103 debug_tree_chain (tree t)
107 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
108 fprintf(stderr, " ");
111 fprintf (stderr, "\n");
114 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
116 print_generic_decl (FILE *file, tree decl, int flags)
118 maybe_init_pretty_print (file);
119 print_declaration (&buffer, decl, 2, flags);
120 pp_write_text_to_stream (&buffer);
123 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
124 to show in the dump. See TDF_* in tree.h. */
127 print_generic_stmt (FILE *file, tree t, int flags)
129 maybe_init_pretty_print (file);
130 dump_generic_node (&buffer, t, 0, flags, true);
134 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
135 to show in the dump. See TDF_* in tree.h. The output is indented by
139 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
143 maybe_init_pretty_print (file);
145 for (i = 0; i < indent; i++)
147 dump_generic_node (&buffer, t, indent, flags, true);
151 /* Print a single expression T on file FILE. FLAGS specifies details to show
152 in the dump. See TDF_* in tree.h. */
155 print_generic_expr (FILE *file, tree t, int flags)
157 maybe_init_pretty_print (file);
158 dump_generic_node (&buffer, t, 0, flags, false);
161 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
165 dump_decl_name (pretty_printer *buffer, tree node, int flags)
170 pp_tree_identifier (buffer, DECL_NAME (t));
171 if ((flags & TDF_UID)
172 || DECL_NAME (t) == NULL_TREE)
174 if (TREE_CODE (t) == LABEL_DECL
175 && LABEL_DECL_UID (t) != -1)
176 pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
180 char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
181 pp_printf (buffer, "%c.%u", c, DECL_UID (t));
186 /* Like the above, but used for pretty printing function calls. */
189 dump_function_name (pretty_printer *buffer, tree node)
191 if (DECL_NAME (node))
192 PRINT_FUNCTION_NAME (node);
194 dump_decl_name (buffer, node, 0);
197 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
198 FLAGS are as in dump_generic_node. */
201 dump_function_declaration (pretty_printer *buffer, tree node,
204 bool wrote_arg = false;
208 pp_character (buffer, '(');
210 /* Print the argument types. The last element in the list is a VOID_TYPE.
211 The following avoids printing the last element. */
212 arg = TYPE_ARG_TYPES (node);
213 while (arg && TREE_CHAIN (arg) && arg != error_mark_node)
216 dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
217 arg = TREE_CHAIN (arg);
218 if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)
220 pp_character (buffer, ',');
226 pp_string (buffer, "void");
228 pp_character (buffer, ')');
231 /* Dump the domain associated with an array. */
234 dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
236 pp_character (buffer, '[');
239 tree min = TYPE_MIN_VALUE (domain);
240 tree max = TYPE_MAX_VALUE (domain);
243 && integer_zerop (min)
244 && host_integerp (max, 0))
245 pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
249 dump_generic_node (buffer, min, spc, flags, false);
250 pp_character (buffer, ':');
252 dump_generic_node (buffer, max, spc, flags, false);
256 pp_string (buffer, "<unknown>");
257 pp_character (buffer, ']');
261 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
262 dump_generic_node. */
265 dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
269 switch (OMP_CLAUSE_CODE (clause))
271 case OMP_CLAUSE_PRIVATE:
274 case OMP_CLAUSE_SHARED:
277 case OMP_CLAUSE_FIRSTPRIVATE:
278 name = "firstprivate";
280 case OMP_CLAUSE_LASTPRIVATE:
281 name = "lastprivate";
283 case OMP_CLAUSE_COPYIN:
286 case OMP_CLAUSE_COPYPRIVATE:
287 name = "copyprivate";
290 pp_string (buffer, name);
291 pp_character (buffer, '(');
292 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
294 pp_character (buffer, ')');
297 case OMP_CLAUSE_REDUCTION:
298 pp_string (buffer, "reduction(");
299 pp_string (buffer, op_symbol_1 (OMP_CLAUSE_REDUCTION_CODE (clause)));
300 pp_character (buffer, ':');
301 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
303 pp_character (buffer, ')');
307 pp_string (buffer, "if(");
308 dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
310 pp_character (buffer, ')');
313 case OMP_CLAUSE_NUM_THREADS:
314 pp_string (buffer, "num_threads(");
315 dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
317 pp_character (buffer, ')');
320 case OMP_CLAUSE_NOWAIT:
321 pp_string (buffer, "nowait");
323 case OMP_CLAUSE_ORDERED:
324 pp_string (buffer, "ordered");
327 case OMP_CLAUSE_DEFAULT:
328 pp_string (buffer, "default(");
329 switch (OMP_CLAUSE_DEFAULT_KIND (clause))
331 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
333 case OMP_CLAUSE_DEFAULT_SHARED:
334 pp_string (buffer, "shared");
336 case OMP_CLAUSE_DEFAULT_NONE:
337 pp_string (buffer, "none");
339 case OMP_CLAUSE_DEFAULT_PRIVATE:
340 pp_string (buffer, "private");
345 pp_character (buffer, ')');
348 case OMP_CLAUSE_SCHEDULE:
349 pp_string (buffer, "schedule(");
350 switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
352 case OMP_CLAUSE_SCHEDULE_STATIC:
353 pp_string (buffer, "static");
355 case OMP_CLAUSE_SCHEDULE_DYNAMIC:
356 pp_string (buffer, "dynamic");
358 case OMP_CLAUSE_SCHEDULE_GUIDED:
359 pp_string (buffer, "guided");
361 case OMP_CLAUSE_SCHEDULE_RUNTIME:
362 pp_string (buffer, "runtime");
367 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
369 pp_character (buffer, ',');
370 dump_generic_node (buffer,
371 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
374 pp_character (buffer, ')');
378 /* Should never happen. */
379 dump_generic_node (buffer, clause, spc, flags, false);
385 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
386 dump_generic_node. */
389 dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
397 dump_omp_clause (buffer, clause, spc, flags);
398 clause = OMP_CLAUSE_CHAIN (clause);
406 /* Dump the set of decls SYMS. BUFFER, SPC and FLAGS are as in
407 dump_generic_node. */
410 dump_symbols (pretty_printer *buffer, bitmap syms, int flags)
416 pp_string (buffer, "NIL");
419 pp_string (buffer, " { ");
421 EXECUTE_IF_SET_IN_BITMAP (syms, 0, i, bi)
423 tree sym = referenced_var_lookup (i);
424 dump_generic_node (buffer, sym, 0, flags, false);
425 pp_string (buffer, " ");
428 pp_string (buffer, "}");
433 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
434 FLAGS specifies details to show in the dump (see TDF_* in tree-pass.h).
435 If IS_STMT is true, the object printed is considered to be a statement
436 and it is terminated by ';' if appropriate. */
439 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
447 if (node == NULL_TREE)
450 is_expr = EXPR_P (node) || GIMPLE_STMT_P (node);
452 /* We use has_stmt_ann because CALL_EXPR can be both an expression
453 and a statement, and we have no guarantee that it will have a
454 stmt_ann when it is used as an RHS expression. stmt_ann will assert
455 if you call it on something with a non-stmt annotation attached. */
456 if (TREE_CODE (node) != ERROR_MARK
457 && is_gimple_stmt (node)
458 && (flags & (TDF_VOPS|TDF_MEMSYMS))
459 && has_stmt_ann (node)
460 && TREE_CODE (node) != PHI_NODE)
461 dump_vops (buffer, node, spc, flags);
463 if (is_stmt && (flags & TDF_STMTADDR))
464 pp_printf (buffer, "<&%p> ", (void *)node);
466 if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
468 expanded_location xloc = expand_location (EXPR_LOCATION (node));
469 pp_character (buffer, '[');
472 pp_string (buffer, xloc.file);
473 pp_string (buffer, " : ");
475 pp_decimal_int (buffer, xloc.line);
476 pp_string (buffer, "] ");
479 switch (TREE_CODE (node))
482 pp_string (buffer, "<<< error >>>");
485 case IDENTIFIER_NODE:
486 pp_tree_identifier (buffer, node);
490 while (node && node != error_mark_node)
492 if (TREE_PURPOSE (node))
494 dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
497 dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
498 node = TREE_CHAIN (node);
499 if (node && TREE_CODE (node) == TREE_LIST)
501 pp_character (buffer, ',');
508 dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
513 if (TREE_VEC_LENGTH (node) > 0)
515 size_t len = TREE_VEC_LENGTH (node);
516 for (i = 0; i < len - 1; i++)
518 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
520 pp_character (buffer, ',');
523 dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
537 unsigned int quals = TYPE_QUALS (node);
538 enum tree_code_class class;
540 if (quals & TYPE_QUAL_CONST)
541 pp_string (buffer, "const ");
542 else if (quals & TYPE_QUAL_VOLATILE)
543 pp_string (buffer, "volatile ");
544 else if (quals & TYPE_QUAL_RESTRICT)
545 pp_string (buffer, "restrict ");
547 class = TREE_CODE_CLASS (TREE_CODE (node));
549 if (class == tcc_declaration)
551 if (DECL_NAME (node))
552 dump_decl_name (buffer, node, flags);
554 pp_string (buffer, "<unnamed type decl>");
556 else if (class == tcc_type)
558 if (TYPE_NAME (node))
560 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
561 pp_tree_identifier (buffer, TYPE_NAME (node));
562 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
563 && DECL_NAME (TYPE_NAME (node)))
564 dump_decl_name (buffer, TYPE_NAME (node), flags);
566 pp_string (buffer, "<unnamed type>");
568 else if (TREE_CODE (node) == VECTOR_TYPE)
570 pp_string (buffer, "vector ");
571 dump_generic_node (buffer, TREE_TYPE (node),
574 else if (TREE_CODE (node) == INTEGER_TYPE)
576 pp_string (buffer, (TYPE_UNSIGNED (node)
577 ? "<unnamed-unsigned:"
578 : "<unnamed-signed:"));
579 pp_decimal_int (buffer, TYPE_PRECISION (node));
580 pp_string (buffer, ">");
583 pp_string (buffer, "<unnamed type>");
590 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
592 if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
594 tree fnode = TREE_TYPE (node);
596 dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
598 pp_character (buffer, '(');
599 pp_string (buffer, str);
600 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
601 dump_decl_name (buffer, TYPE_NAME (node), flags);
603 pp_printf (buffer, "<T%x>", TYPE_UID (node));
605 pp_character (buffer, ')');
606 dump_function_declaration (buffer, fnode, spc, flags);
610 unsigned int quals = TYPE_QUALS (node);
612 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
614 pp_string (buffer, str);
616 if (quals & TYPE_QUAL_CONST)
617 pp_string (buffer, " const");
618 else if (quals & TYPE_QUAL_VOLATILE)
619 pp_string (buffer, "volatile");
620 else if (quals & TYPE_QUAL_RESTRICT)
621 pp_string (buffer, " restrict");
623 if (TYPE_REF_CAN_ALIAS_ALL (node))
624 pp_string (buffer, " {ref-all}");
633 dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
634 pp_string (buffer, "::");
639 const char *sep = "";
642 pp_string (buffer, "MEM[");
644 tmp = TMR_SYMBOL (node);
647 pp_string (buffer, sep);
649 pp_string (buffer, "symbol: ");
650 dump_generic_node (buffer, tmp, spc, flags, false);
652 tmp = TMR_BASE (node);
655 pp_string (buffer, sep);
657 pp_string (buffer, "base: ");
658 dump_generic_node (buffer, tmp, spc, flags, false);
660 tmp = TMR_INDEX (node);
663 pp_string (buffer, sep);
665 pp_string (buffer, "index: ");
666 dump_generic_node (buffer, tmp, spc, flags, false);
668 tmp = TMR_STEP (node);
671 pp_string (buffer, sep);
673 pp_string (buffer, "step: ");
674 dump_generic_node (buffer, tmp, spc, flags, false);
676 tmp = TMR_OFFSET (node);
679 pp_string (buffer, sep);
681 pp_string (buffer, "offset: ");
682 dump_generic_node (buffer, tmp, spc, flags, false);
684 pp_string (buffer, "]");
685 if (flags & TDF_DETAILS)
687 pp_string (buffer, "{");
688 dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,
690 pp_string (buffer, "}");
699 /* Print the innermost component type. */
700 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
701 tmp = TREE_TYPE (tmp))
703 dump_generic_node (buffer, tmp, spc, flags, false);
705 /* Print the dimensions. */
706 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
707 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
713 case QUAL_UNION_TYPE:
714 /* Print the name of the structure. */
715 if (TREE_CODE (node) == RECORD_TYPE)
716 pp_string (buffer, "struct ");
717 else if (TREE_CODE (node) == UNION_TYPE)
718 pp_string (buffer, "union ");
720 if (TYPE_NAME (node))
721 dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
723 print_struct_decl (buffer, node, spc, flags);
731 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
733 /* In the case of a pointer, one may want to divide by the
734 size of the pointed-to type. Unfortunately, this not
735 straightforward. The C front-end maps expressions
740 in such a way that the two INTEGER_CST nodes for "5" have
741 different values but identical types. In the latter
742 case, the 5 is multiplied by sizeof (int) in c-common.c
743 (pointer_int_sum) to convert it to a byte address, and
744 yet the type of the node is left unchanged. Argh. What
745 is consistent though is that the number value corresponds
746 to bytes (UNITS) offset.
748 NB: Neither of the following divisors can be trivially
749 used to recover the original literal:
751 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
752 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
753 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
754 pp_string (buffer, "B"); /* pseudo-unit */
756 else if (! host_integerp (node, 0))
759 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
760 HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);
762 if (tree_int_cst_sgn (val) < 0)
764 pp_character (buffer, '-');
768 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
770 sprintf (pp_buffer (buffer)->digit_buffer,
771 HOST_WIDE_INT_PRINT_DOUBLE_HEX, high, low);
772 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
775 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
779 /* Code copied from print_node. */
782 if (TREE_OVERFLOW (node))
783 pp_string (buffer, " overflow");
785 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
786 d = TREE_REAL_CST (node);
787 if (REAL_VALUE_ISINF (d))
788 pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
789 else if (REAL_VALUE_ISNAN (d))
790 pp_string (buffer, " Nan");
794 real_to_decimal (string, &d, sizeof (string), 0, 1);
795 pp_string (buffer, string);
800 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
801 pp_string (buffer, "0x");
802 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
803 output_formatted_integer (buffer, "%02x", *p++);
810 pp_string (buffer, "__complex__ (");
811 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
812 pp_string (buffer, ", ");
813 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
814 pp_string (buffer, ")");
818 pp_string (buffer, "\"");
819 pretty_print_string (buffer, TREE_STRING_POINTER (node));
820 pp_string (buffer, "\"");
826 pp_string (buffer, "{ ");
827 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
829 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
830 if (TREE_CHAIN (elt))
831 pp_string (buffer, ", ");
833 pp_string (buffer, " }");
842 dump_decl_name (buffer, node, flags);
846 if (DECL_NAME (node))
847 dump_decl_name (buffer, node, flags);
848 else if (LABEL_DECL_UID (node) != -1)
849 pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
850 LABEL_DECL_UID (node));
852 pp_printf (buffer, "<D%u>", DECL_UID (node));
856 if (DECL_IS_BUILTIN (node))
858 /* Don't print the declaration of built-in types. */
861 if (DECL_NAME (node))
862 dump_decl_name (buffer, node, flags);
865 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
866 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
867 && TYPE_METHODS (TREE_TYPE (node)))
869 /* The type is a c++ class: all structures have at least
871 pp_string (buffer, "class ");
872 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
877 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
878 ? "union" : "struct "));
879 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
884 case SYMBOL_MEMORY_TAG:
885 case NAME_MEMORY_TAG:
886 case STRUCT_FIELD_TAG:
891 case MEMORY_PARTITION_TAG:
892 dump_decl_name (buffer, node, flags);
896 pp_string (buffer, "<retval>");
900 op0 = TREE_OPERAND (node, 0);
902 if (TREE_CODE (op0) == INDIRECT_REF)
904 op0 = TREE_OPERAND (op0, 0);
907 if (op_prio (op0) < op_prio (node))
908 pp_character (buffer, '(');
909 dump_generic_node (buffer, op0, spc, flags, false);
910 if (op_prio (op0) < op_prio (node))
911 pp_character (buffer, ')');
912 pp_string (buffer, str);
913 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
915 if (TREE_CODE (op0) != VALUE_HANDLE)
917 op0 = component_ref_field_offset (node);
918 if (op0 && TREE_CODE (op0) != INTEGER_CST)
920 pp_string (buffer, "{off: ");
921 dump_generic_node (buffer, op0, spc, flags, false);
922 pp_character (buffer, '}');
928 pp_string (buffer, "BIT_FIELD_REF <");
929 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
930 pp_string (buffer, ", ");
931 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
932 pp_string (buffer, ", ");
933 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
934 pp_string (buffer, ">");
938 case ARRAY_RANGE_REF:
939 op0 = TREE_OPERAND (node, 0);
940 if (op_prio (op0) < op_prio (node))
941 pp_character (buffer, '(');
942 dump_generic_node (buffer, op0, spc, flags, false);
943 if (op_prio (op0) < op_prio (node))
944 pp_character (buffer, ')');
945 pp_character (buffer, '[');
946 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
947 if (TREE_CODE (node) == ARRAY_RANGE_REF)
948 pp_string (buffer, " ...");
949 pp_character (buffer, ']');
951 op0 = array_ref_low_bound (node);
952 op1 = array_ref_element_size (node);
954 if (!integer_zerop (op0)
955 || TREE_OPERAND (node, 2)
956 || TREE_OPERAND (node, 3))
958 pp_string (buffer, "{lb: ");
959 dump_generic_node (buffer, op0, spc, flags, false);
960 pp_string (buffer, " sz: ");
961 dump_generic_node (buffer, op1, spc, flags, false);
962 pp_character (buffer, '}');
968 unsigned HOST_WIDE_INT ix;
970 bool is_struct_init = FALSE;
971 pp_character (buffer, '{');
972 if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
973 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
974 is_struct_init = TRUE;
975 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
977 if (field && is_struct_init)
979 pp_character (buffer, '.');
980 dump_generic_node (buffer, field, spc, flags, false);
981 pp_string (buffer, "=");
983 if (val && TREE_CODE (val) == ADDR_EXPR)
984 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
985 val = TREE_OPERAND (val, 0);
986 if (val && TREE_CODE (val) == FUNCTION_DECL)
987 dump_decl_name (buffer, val, flags);
989 dump_generic_node (buffer, val, spc, flags, false);
990 if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
992 pp_character (buffer, ',');
996 pp_character (buffer, '}');
1003 if (flags & TDF_SLIM)
1005 pp_string (buffer, "<COMPOUND_EXPR>");
1009 dump_generic_node (buffer, TREE_OPERAND (node, 0),
1010 spc, flags, !(flags & TDF_SLIM));
1011 if (flags & TDF_SLIM)
1012 newline_and_indent (buffer, spc);
1015 pp_character (buffer, ',');
1019 for (tp = &TREE_OPERAND (node, 1);
1020 TREE_CODE (*tp) == COMPOUND_EXPR;
1021 tp = &TREE_OPERAND (*tp, 1))
1023 dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
1024 spc, flags, !(flags & TDF_SLIM));
1025 if (flags & TDF_SLIM)
1026 newline_and_indent (buffer, spc);
1029 pp_character (buffer, ',');
1034 dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
1038 case STATEMENT_LIST:
1040 tree_stmt_iterator si;
1043 if (flags & TDF_SLIM)
1045 pp_string (buffer, "<STATEMENT_LIST>");
1049 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1052 newline_and_indent (buffer, spc);
1055 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
1061 case GIMPLE_MODIFY_STMT:
1063 dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 0), spc, flags,
1066 pp_character (buffer, '=');
1068 dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
1073 pp_string (buffer, "TARGET_EXPR <");
1074 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1075 pp_character (buffer, ',');
1077 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
1078 pp_character (buffer, '>');
1082 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1087 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1089 pp_string (buffer, "if (");
1090 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1091 pp_character (buffer, ')');
1092 /* The lowered cond_exprs should always be printed in full. */
1093 if (COND_EXPR_THEN (node)
1094 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1095 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1096 && COND_EXPR_ELSE (node)
1097 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1098 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1101 dump_generic_node (buffer, COND_EXPR_THEN (node),
1103 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1105 pp_string (buffer, " else ");
1106 dump_generic_node (buffer, COND_EXPR_ELSE (node),
1110 else if (!(flags & TDF_SLIM))
1112 /* Output COND_EXPR_THEN. */
1113 if (COND_EXPR_THEN (node))
1115 newline_and_indent (buffer, spc+2);
1116 pp_character (buffer, '{');
1117 newline_and_indent (buffer, spc+4);
1118 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1120 newline_and_indent (buffer, spc+2);
1121 pp_character (buffer, '}');
1124 /* Output COND_EXPR_ELSE. */
1125 if (COND_EXPR_ELSE (node)
1126 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1128 newline_and_indent (buffer, spc);
1129 pp_string (buffer, "else");
1130 newline_and_indent (buffer, spc+2);
1131 pp_character (buffer, '{');
1132 newline_and_indent (buffer, spc+4);
1133 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1135 newline_and_indent (buffer, spc+2);
1136 pp_character (buffer, '}');
1143 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1145 pp_character (buffer, '?');
1147 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1149 pp_character (buffer, ':');
1151 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1156 pp_character (buffer, '{');
1157 if (!(flags & TDF_SLIM))
1159 if (BIND_EXPR_VARS (node))
1161 pp_newline (buffer);
1163 for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
1165 print_declaration (buffer, op0, spc+2, flags);
1166 pp_newline (buffer);
1170 newline_and_indent (buffer, spc+2);
1171 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1172 newline_and_indent (buffer, spc);
1173 pp_character (buffer, '}');
1179 print_call_name (buffer, node);
1181 /* Print parameters. */
1183 pp_character (buffer, '(');
1186 call_expr_arg_iterator iter;
1187 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
1189 dump_generic_node (buffer, arg, spc, flags, false);
1190 if (more_call_expr_args_p (&iter))
1192 pp_character (buffer, ',');
1197 pp_character (buffer, ')');
1199 op1 = CALL_EXPR_STATIC_CHAIN (node);
1202 pp_string (buffer, " [static-chain: ");
1203 dump_generic_node (buffer, op1, spc, flags, false);
1204 pp_character (buffer, ']');
1207 if (CALL_EXPR_RETURN_SLOT_OPT (node))
1208 pp_string (buffer, " [return slot optimization]");
1209 if (CALL_EXPR_TAILCALL (node))
1210 pp_string (buffer, " [tail call]");
1213 case WITH_CLEANUP_EXPR:
1217 case CLEANUP_POINT_EXPR:
1218 pp_string (buffer, "<<cleanup_point ");
1219 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1220 pp_string (buffer, ">>");
1223 case PLACEHOLDER_EXPR:
1224 pp_string (buffer, "<PLACEHOLDER_EXPR ");
1225 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1226 pp_character (buffer, '>');
1229 /* Binary arithmetic and logic expressions. */
1230 case WIDEN_SUM_EXPR:
1231 case WIDEN_MULT_EXPR:
1235 case TRUNC_DIV_EXPR:
1237 case FLOOR_DIV_EXPR:
1238 case ROUND_DIV_EXPR:
1239 case TRUNC_MOD_EXPR:
1241 case FLOOR_MOD_EXPR:
1242 case ROUND_MOD_EXPR:
1244 case EXACT_DIV_EXPR:
1249 case VEC_LSHIFT_EXPR:
1250 case VEC_RSHIFT_EXPR:
1254 case TRUTH_ANDIF_EXPR:
1255 case TRUTH_ORIF_EXPR:
1256 case TRUTH_AND_EXPR:
1258 case TRUTH_XOR_EXPR:
1272 case UNORDERED_EXPR:
1274 const char *op = op_symbol (node);
1275 op0 = TREE_OPERAND (node, 0);
1276 op1 = TREE_OPERAND (node, 1);
1278 /* When the operands are expressions with less priority,
1279 keep semantics of the tree representation. */
1280 if (op_prio (op0) <= op_prio (node))
1282 pp_character (buffer, '(');
1283 dump_generic_node (buffer, op0, spc, flags, false);
1284 pp_character (buffer, ')');
1287 dump_generic_node (buffer, op0, spc, flags, false);
1290 pp_string (buffer, op);
1293 /* When the operands are expressions with less priority,
1294 keep semantics of the tree representation. */
1295 if (op_prio (op1) <= op_prio (node))
1297 pp_character (buffer, '(');
1298 dump_generic_node (buffer, op1, spc, flags, false);
1299 pp_character (buffer, ')');
1302 dump_generic_node (buffer, op1, spc, flags, false);
1306 /* Unary arithmetic and logic expressions. */
1309 case TRUTH_NOT_EXPR:
1311 case PREDECREMENT_EXPR:
1312 case PREINCREMENT_EXPR:
1313 case ALIGN_INDIRECT_REF:
1314 case MISALIGNED_INDIRECT_REF:
1316 if (TREE_CODE (node) == ADDR_EXPR
1317 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1318 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1319 ; /* Do not output '&' for strings and function pointers. */
1321 pp_string (buffer, op_symbol (node));
1323 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1325 pp_character (buffer, '(');
1326 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1327 pp_character (buffer, ')');
1330 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1332 if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1334 pp_string (buffer, "{misalignment: ");
1335 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1336 pp_character (buffer, '}');
1340 case POSTDECREMENT_EXPR:
1341 case POSTINCREMENT_EXPR:
1342 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1344 pp_character (buffer, '(');
1345 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1346 pp_character (buffer, ')');
1349 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1350 pp_string (buffer, op_symbol (node));
1354 pp_string (buffer, "MIN_EXPR <");
1355 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1356 pp_string (buffer, ", ");
1357 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1358 pp_character (buffer, '>');
1362 pp_string (buffer, "MAX_EXPR <");
1363 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1364 pp_string (buffer, ", ");
1365 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1366 pp_character (buffer, '>');
1370 pp_string (buffer, "ABS_EXPR <");
1371 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1372 pp_character (buffer, '>');
1379 case FIX_TRUNC_EXPR:
1383 type = TREE_TYPE (node);
1384 op0 = TREE_OPERAND (node, 0);
1385 if (type != TREE_TYPE (op0))
1387 pp_character (buffer, '(');
1388 dump_generic_node (buffer, type, spc, flags, false);
1389 pp_string (buffer, ") ");
1391 if (op_prio (op0) < op_prio (node))
1392 pp_character (buffer, '(');
1393 dump_generic_node (buffer, op0, spc, flags, false);
1394 if (op_prio (op0) < op_prio (node))
1395 pp_character (buffer, ')');
1398 case VIEW_CONVERT_EXPR:
1399 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1400 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1401 pp_string (buffer, ">(");
1402 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1403 pp_character (buffer, ')');
1406 case NON_LVALUE_EXPR:
1407 pp_string (buffer, "NON_LVALUE_EXPR <");
1408 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1409 pp_character (buffer, '>');
1413 pp_string (buffer, "SAVE_EXPR <");
1414 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1415 pp_character (buffer, '>');
1419 pp_string (buffer, "COMPLEX_EXPR <");
1420 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1421 pp_string (buffer, ", ");
1422 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1423 pp_string (buffer, ">");
1427 pp_string (buffer, "CONJ_EXPR <");
1428 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1429 pp_string (buffer, ">");
1433 pp_string (buffer, "REALPART_EXPR <");
1434 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1435 pp_string (buffer, ">");
1439 pp_string (buffer, "IMAGPART_EXPR <");
1440 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1441 pp_string (buffer, ">");
1445 pp_string (buffer, "VA_ARG_EXPR <");
1446 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1447 pp_string (buffer, ">");
1450 case TRY_FINALLY_EXPR:
1451 case TRY_CATCH_EXPR:
1452 pp_string (buffer, "try");
1453 newline_and_indent (buffer, spc+2);
1454 pp_string (buffer, "{");
1455 newline_and_indent (buffer, spc+4);
1456 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1457 newline_and_indent (buffer, spc+2);
1458 pp_string (buffer, "}");
1459 newline_and_indent (buffer, spc);
1461 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1462 newline_and_indent (buffer, spc+2);
1463 pp_string (buffer, "{");
1464 newline_and_indent (buffer, spc+4);
1465 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1466 newline_and_indent (buffer, spc+2);
1467 pp_string (buffer, "}");
1472 pp_string (buffer, "catch (");
1473 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1474 pp_string (buffer, ")");
1475 newline_and_indent (buffer, spc+2);
1476 pp_string (buffer, "{");
1477 newline_and_indent (buffer, spc+4);
1478 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1479 newline_and_indent (buffer, spc+2);
1480 pp_string (buffer, "}");
1484 case EH_FILTER_EXPR:
1485 pp_string (buffer, "<<<eh_filter (");
1486 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1487 pp_string (buffer, ")>>>");
1488 newline_and_indent (buffer, spc+2);
1489 pp_string (buffer, "{");
1490 newline_and_indent (buffer, spc+4);
1491 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1492 newline_and_indent (buffer, spc+2);
1493 pp_string (buffer, "}");
1498 op0 = TREE_OPERAND (node, 0);
1499 /* If this is for break or continue, don't bother printing it. */
1500 if (DECL_NAME (op0))
1502 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1503 if (strcmp (name, "break") == 0
1504 || strcmp (name, "continue") == 0)
1507 dump_generic_node (buffer, op0, spc, flags, false);
1508 pp_character (buffer, ':');
1509 if (DECL_NONLOCAL (op0))
1510 pp_string (buffer, " [non-local]");
1514 pp_string (buffer, "<<<exception object>>>");
1518 pp_string (buffer, "<<<filter object>>>");
1522 pp_string (buffer, "while (1)");
1523 if (!(flags & TDF_SLIM))
1525 newline_and_indent (buffer, spc+2);
1526 pp_character (buffer, '{');
1527 newline_and_indent (buffer, spc+4);
1528 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1529 newline_and_indent (buffer, spc+2);
1530 pp_character (buffer, '}');
1536 pp_string (buffer, "return");
1537 op0 = TREE_OPERAND (node, 0);
1541 if (TREE_CODE (op0) == MODIFY_EXPR
1542 || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
1543 dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
1546 dump_generic_node (buffer, op0, spc, flags, false);
1551 pp_string (buffer, "if (");
1552 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1553 pp_string (buffer, ") break");
1557 pp_string (buffer, "switch (");
1558 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1559 pp_character (buffer, ')');
1560 if (!(flags & TDF_SLIM))
1562 newline_and_indent (buffer, spc+2);
1563 pp_character (buffer, '{');
1564 if (SWITCH_BODY (node))
1566 newline_and_indent (buffer, spc+4);
1567 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1572 tree vec = SWITCH_LABELS (node);
1573 size_t i, n = TREE_VEC_LENGTH (vec);
1574 for (i = 0; i < n; ++i)
1576 tree elt = TREE_VEC_ELT (vec, i);
1577 newline_and_indent (buffer, spc+4);
1580 dump_generic_node (buffer, elt, spc+4, flags, false);
1581 pp_string (buffer, " goto ");
1582 dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1584 pp_semicolon (buffer);
1587 pp_string (buffer, "case ???: goto ???;");
1590 newline_and_indent (buffer, spc+2);
1591 pp_character (buffer, '}');
1597 op0 = GOTO_DESTINATION (node);
1598 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1600 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1601 if (strcmp (name, "break") == 0
1602 || strcmp (name, "continue") == 0)
1604 pp_string (buffer, name);
1608 pp_string (buffer, "goto ");
1609 dump_generic_node (buffer, op0, spc, flags, false);
1613 pp_string (buffer, "resx ");
1614 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1618 pp_string (buffer, "__asm__");
1619 if (ASM_VOLATILE_P (node))
1620 pp_string (buffer, " __volatile__");
1621 pp_character (buffer, '(');
1622 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1623 pp_character (buffer, ':');
1624 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1625 pp_character (buffer, ':');
1626 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1627 if (ASM_CLOBBERS (node))
1629 pp_character (buffer, ':');
1630 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1632 pp_string (buffer, ")");
1635 case CASE_LABEL_EXPR:
1636 if (CASE_LOW (node) && CASE_HIGH (node))
1638 pp_string (buffer, "case ");
1639 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1640 pp_string (buffer, " ... ");
1641 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1643 else if (CASE_LOW (node))
1645 pp_string (buffer, "case ");
1646 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1649 pp_string (buffer, "default ");
1650 pp_character (buffer, ':');
1654 pp_string (buffer, "OBJ_TYPE_REF(");
1655 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1656 pp_character (buffer, ';');
1657 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1658 pp_character (buffer, '-');
1659 pp_character (buffer, '>');
1660 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1661 pp_character (buffer, ')');
1668 dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1669 pp_string (buffer, " = PHI <");
1670 for (i = 0; i < PHI_NUM_ARGS (node); i++)
1672 dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1673 pp_string (buffer, "(");
1674 pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1675 pp_string (buffer, ")");
1676 if (i < PHI_NUM_ARGS (node) - 1)
1677 pp_string (buffer, ", ");
1679 pp_string (buffer, ">");
1681 if (stmt_references_memory_p (node) && (flags & TDF_MEMSYMS))
1682 dump_symbols (buffer, STORED_SYMS (node), flags);
1687 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1688 pp_string (buffer, "_");
1689 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1690 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1691 pp_string (buffer, "(ab)");
1692 else if (SSA_NAME_IS_DEFAULT_DEF (node))
1693 pp_string (buffer, "(D)");
1696 case WITH_SIZE_EXPR:
1697 pp_string (buffer, "WITH_SIZE_EXPR <");
1698 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1699 pp_string (buffer, ", ");
1700 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1701 pp_string (buffer, ">");
1705 pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1709 pp_string (buffer, "ASSERT_EXPR <");
1710 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1711 pp_string (buffer, ", ");
1712 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1713 pp_string (buffer, ">");
1717 pp_string (buffer, "scev_known");
1720 case SCEV_NOT_KNOWN:
1721 pp_string (buffer, "scev_not_known");
1724 case POLYNOMIAL_CHREC:
1725 pp_string (buffer, "{");
1726 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1727 pp_string (buffer, ", +, ");
1728 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1729 pp_string (buffer, "}_");
1730 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1734 case REALIGN_LOAD_EXPR:
1735 pp_string (buffer, "REALIGN_LOAD <");
1736 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1737 pp_string (buffer, ", ");
1738 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1739 pp_string (buffer, ", ");
1740 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1741 pp_string (buffer, ">");
1745 pp_string (buffer, " VEC_COND_EXPR < ");
1746 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1747 pp_string (buffer, " , ");
1748 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1749 pp_string (buffer, " , ");
1750 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1751 pp_string (buffer, " > ");
1755 pp_string (buffer, " DOT_PROD_EXPR < ");
1756 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1757 pp_string (buffer, ", ");
1758 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1759 pp_string (buffer, ", ");
1760 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1761 pp_string (buffer, " > ");
1765 pp_string (buffer, "#pragma omp parallel");
1766 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
1767 if (OMP_PARALLEL_FN (node))
1769 pp_string (buffer, " [child fn: ");
1770 dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);
1772 pp_string (buffer, " (");
1774 if (OMP_PARALLEL_DATA_ARG (node))
1775 dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,
1778 pp_string (buffer, "???");
1780 pp_string (buffer, ")]");
1784 if (!(flags & TDF_SLIM) && OMP_BODY (node))
1786 newline_and_indent (buffer, spc + 2);
1787 pp_character (buffer, '{');
1788 newline_and_indent (buffer, spc + 4);
1789 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
1790 newline_and_indent (buffer, spc + 2);
1791 pp_character (buffer, '}');
1797 pp_string (buffer, "#pragma omp for");
1798 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
1800 if (!(flags & TDF_SLIM))
1802 if (OMP_FOR_PRE_BODY (node))
1804 newline_and_indent (buffer, spc + 2);
1805 pp_character (buffer, '{');
1807 newline_and_indent (buffer, spc);
1808 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
1811 newline_and_indent (buffer, spc);
1812 pp_string (buffer, "for (");
1813 dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);
1814 pp_string (buffer, "; ");
1815 dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);
1816 pp_string (buffer, "; ");
1817 dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);
1818 pp_string (buffer, ")");
1819 if (OMP_FOR_BODY (node))
1821 newline_and_indent (buffer, spc + 2);
1822 pp_character (buffer, '{');
1823 newline_and_indent (buffer, spc + 4);
1824 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
1826 newline_and_indent (buffer, spc + 2);
1827 pp_character (buffer, '}');
1829 if (OMP_FOR_PRE_BODY (node))
1832 newline_and_indent (buffer, spc + 2);
1833 pp_character (buffer, '}');
1840 pp_string (buffer, "#pragma omp sections");
1841 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
1845 pp_string (buffer, "#pragma omp section");
1849 pp_string (buffer, "#pragma omp master");
1853 pp_string (buffer, "#pragma omp ordered");
1857 pp_string (buffer, "#pragma omp critical");
1858 if (OMP_CRITICAL_NAME (node))
1861 pp_character (buffer, '(');
1862 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
1864 pp_character (buffer, ')');
1869 pp_string (buffer, "#pragma omp atomic");
1870 newline_and_indent (buffer, spc + 2);
1871 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1873 pp_character (buffer, '=');
1875 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1879 pp_string (buffer, "#pragma omp single");
1880 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
1884 pp_string (buffer, "OMP_RETURN");
1885 if (OMP_RETURN_NOWAIT (node))
1886 pp_string (buffer, " [nowait]");
1891 pp_string (buffer, "OMP_CONTINUE");
1896 dump_omp_clause (buffer, node, spc, flags);
1900 case REDUC_MAX_EXPR:
1901 pp_string (buffer, " REDUC_MAX_EXPR < ");
1902 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1903 pp_string (buffer, " > ");
1906 case REDUC_MIN_EXPR:
1907 pp_string (buffer, " REDUC_MIN_EXPR < ");
1908 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1909 pp_string (buffer, " > ");
1912 case REDUC_PLUS_EXPR:
1913 pp_string (buffer, " REDUC_PLUS_EXPR < ");
1914 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1915 pp_string (buffer, " > ");
1918 case VEC_WIDEN_MULT_HI_EXPR:
1919 pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
1920 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1921 pp_string (buffer, ", ");
1922 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1923 pp_string (buffer, " > ");
1926 case VEC_WIDEN_MULT_LO_EXPR:
1927 pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
1928 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1929 pp_string (buffer, ", ");
1930 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1931 pp_string (buffer, " > ");
1934 case VEC_UNPACK_HI_EXPR:
1935 pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
1936 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1937 pp_string (buffer, " > ");
1940 case VEC_UNPACK_LO_EXPR:
1941 pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
1942 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1943 pp_string (buffer, " > ");
1946 case VEC_PACK_TRUNC_EXPR:
1947 pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
1948 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1949 pp_string (buffer, ", ");
1950 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1951 pp_string (buffer, " > ");
1954 case VEC_PACK_SAT_EXPR:
1955 pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
1956 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1957 pp_string (buffer, ", ");
1958 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1959 pp_string (buffer, " > ");
1965 pp_string (buffer, "BLOCK");
1967 if (BLOCK_ABSTRACT (node))
1968 pp_string (buffer, " [abstract]");
1970 if (TREE_ASM_WRITTEN (node))
1971 pp_string (buffer, " [written]");
1973 newline_and_indent (buffer, spc + 2);
1975 if (BLOCK_SUPERCONTEXT (node))
1977 pp_string (buffer, "SUPERCONTEXT: ");
1978 if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
1979 pp_printf (buffer, "BLOCK %p",
1980 (void *)BLOCK_SUPERCONTEXT (node));
1982 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
1984 newline_and_indent (buffer, spc + 2);
1987 if (BLOCK_SUBBLOCKS (node))
1989 pp_string (buffer, "SUBBLOCKS: ");
1990 for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
1991 pp_printf (buffer, "%p ", (void *)t);
1992 newline_and_indent (buffer, spc + 2);
1995 if (BLOCK_VARS (node))
1997 pp_string (buffer, "VARS: ");
1998 for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
2000 dump_generic_node (buffer, t, 0, flags, false);
2001 pp_string (buffer, " ");
2003 newline_and_indent (buffer, spc + 2);
2006 if (BLOCK_ABSTRACT_ORIGIN (node))
2008 pp_string (buffer, "ABSTRACT_ORIGIN: ");
2009 if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
2010 pp_printf (buffer, "BLOCK %p",
2011 (void *)BLOCK_ABSTRACT_ORIGIN (node));
2013 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
2015 newline_and_indent (buffer, spc + 2);
2020 case VEC_EXTRACT_EVEN_EXPR:
2021 pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
2022 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2023 pp_string (buffer, ", ");
2024 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2025 pp_string (buffer, " > ");
2028 case VEC_EXTRACT_ODD_EXPR:
2029 pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
2030 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2031 pp_string (buffer, ", ");
2032 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2033 pp_string (buffer, " > ");
2036 case VEC_INTERLEAVE_HIGH_EXPR:
2037 pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
2038 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2039 pp_string (buffer, ", ");
2040 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2041 pp_string (buffer, " > ");
2044 case VEC_INTERLEAVE_LOW_EXPR:
2045 pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
2046 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2047 pp_string (buffer, ", ");
2048 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2049 pp_string (buffer, " > ");
2056 if (is_stmt && is_expr)
2057 pp_semicolon (buffer);
2059 /* If we're building a diagnostic, the formatted text will be written
2060 into BUFFER's stream by the caller; otherwise, write it now. */
2061 if (!(flags & TDF_DIAGNOSTIC))
2062 pp_write_text_to_stream (buffer);
2067 /* Print the declaration of a variable. */
2070 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2074 if (TREE_CODE (t) == TYPE_DECL)
2075 pp_string (buffer, "typedef ");
2077 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2078 pp_string (buffer, "register ");
2080 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2081 pp_string (buffer, "extern ");
2082 else if (TREE_STATIC (t))
2083 pp_string (buffer, "static ");
2085 /* Print the type and name. */
2086 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2090 /* Print array's type. */
2091 tmp = TREE_TYPE (t);
2092 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2093 tmp = TREE_TYPE (tmp);
2094 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2096 /* Print variable's name. */
2098 dump_generic_node (buffer, t, spc, flags, false);
2100 /* Print the dimensions. */
2101 tmp = TREE_TYPE (t);
2102 while (TREE_CODE (tmp) == ARRAY_TYPE)
2104 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
2105 tmp = TREE_TYPE (tmp);
2108 else if (TREE_CODE (t) == FUNCTION_DECL)
2110 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2112 dump_decl_name (buffer, t, flags);
2113 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2117 /* Print type declaration. */
2118 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2120 /* Print variable's name. */
2122 dump_generic_node (buffer, t, spc, flags, false);
2125 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2127 pp_string (buffer, " __asm__ ");
2128 pp_character (buffer, '(');
2129 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2130 pp_character (buffer, ')');
2133 /* The initial value of a function serves to determine wether the function
2134 is declared or defined. So the following does not apply to function
2136 if (TREE_CODE (t) != FUNCTION_DECL)
2138 /* Print the initial value. */
2139 if (DECL_INITIAL (t))
2142 pp_character (buffer, '=');
2144 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2148 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2150 pp_string (buffer, " [value-expr: ");
2151 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2152 pp_character (buffer, ']');
2155 pp_character (buffer, ';');
2159 /* Prints a structure: name, fields, and methods.
2160 FIXME: Still incomplete. */
2163 print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
2165 /* Print the name of the structure. */
2166 if (TYPE_NAME (node))
2169 if (TREE_CODE (node) == RECORD_TYPE)
2170 pp_string (buffer, "struct ");
2171 else if ((TREE_CODE (node) == UNION_TYPE
2172 || TREE_CODE (node) == QUAL_UNION_TYPE))
2173 pp_string (buffer, "union ");
2175 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2178 /* Print the contents of the structure. */
2179 pp_newline (buffer);
2181 pp_character (buffer, '{');
2182 pp_newline (buffer);
2184 /* Print the fields of the structure. */
2187 tmp = TYPE_FIELDS (node);
2190 /* Avoid to print recursively the structure. */
2191 /* FIXME : Not implemented correctly...,
2192 what about the case when we have a cycle in the contain graph? ...
2193 Maybe this could be solved by looking at the scope in which the
2194 structure was declared. */
2195 if (TREE_TYPE (tmp) != node
2196 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
2197 && TREE_TYPE (TREE_TYPE (tmp)) != node))
2199 print_declaration (buffer, tmp, spc+2, flags);
2200 pp_newline (buffer);
2202 tmp = TREE_CHAIN (tmp);
2206 pp_character (buffer, '}');
2209 /* Return the priority of the operator OP.
2211 From lowest to highest precedence with either left-to-right (L-R)
2212 or right-to-left (R-L) associativity]:
2215 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2227 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2228 15 [L-R] fn() [] -> .
2230 unary +, - and * have higher precedence than the corresponding binary
2239 switch (TREE_CODE (op))
2247 case GIMPLE_MODIFY_STMT:
2255 case TRUTH_ORIF_EXPR:
2258 case TRUTH_AND_EXPR:
2259 case TRUTH_ANDIF_EXPR:
2266 case TRUTH_XOR_EXPR:
2283 case UNORDERED_EXPR:
2296 case WIDEN_SUM_EXPR:
2301 case VEC_WIDEN_MULT_HI_EXPR:
2302 case VEC_WIDEN_MULT_LO_EXPR:
2303 case WIDEN_MULT_EXPR:
2306 case TRUNC_DIV_EXPR:
2308 case FLOOR_DIV_EXPR:
2309 case ROUND_DIV_EXPR:
2311 case EXACT_DIV_EXPR:
2312 case TRUNC_MOD_EXPR:
2314 case FLOOR_MOD_EXPR:
2315 case ROUND_MOD_EXPR:
2318 case TRUTH_NOT_EXPR:
2320 case POSTINCREMENT_EXPR:
2321 case POSTDECREMENT_EXPR:
2322 case PREINCREMENT_EXPR:
2323 case PREDECREMENT_EXPR:
2325 case ALIGN_INDIRECT_REF:
2326 case MISALIGNED_INDIRECT_REF:
2332 case FIX_TRUNC_EXPR:
2338 case ARRAY_RANGE_REF:
2342 /* Special expressions. */
2348 case REDUC_MAX_EXPR:
2349 case REDUC_MIN_EXPR:
2350 case REDUC_PLUS_EXPR:
2351 case VEC_LSHIFT_EXPR:
2352 case VEC_RSHIFT_EXPR:
2353 case VEC_UNPACK_HI_EXPR:
2354 case VEC_UNPACK_LO_EXPR:
2355 case VEC_PACK_TRUNC_EXPR:
2356 case VEC_PACK_SAT_EXPR:
2360 case NON_LVALUE_EXPR:
2361 return op_prio (TREE_OPERAND (op, 0));
2364 /* Return an arbitrarily high precedence to avoid surrounding single
2365 VAR_DECLs in ()s. */
2371 /* Return the symbol associated with operator OP. */
2374 op_symbol_1 (enum tree_code code)
2379 case GIMPLE_MODIFY_STMT:
2383 case TRUTH_ORIF_EXPR:
2386 case TRUTH_AND_EXPR:
2387 case TRUTH_ANDIF_EXPR:
2393 case TRUTH_XOR_EXPR:
2403 case UNORDERED_EXPR:
2449 case VEC_LSHIFT_EXPR:
2452 case VEC_RSHIFT_EXPR:
2458 case REDUC_PLUS_EXPR:
2461 case WIDEN_SUM_EXPR:
2464 case WIDEN_MULT_EXPR:
2474 case TRUTH_NOT_EXPR:
2481 case ALIGN_INDIRECT_REF:
2484 case MISALIGNED_INDIRECT_REF:
2487 case TRUNC_DIV_EXPR:
2494 case FLOOR_DIV_EXPR:
2497 case ROUND_DIV_EXPR:
2500 case EXACT_DIV_EXPR:
2503 case TRUNC_MOD_EXPR:
2509 case FLOOR_MOD_EXPR:
2512 case ROUND_MOD_EXPR:
2515 case PREDECREMENT_EXPR:
2518 case PREINCREMENT_EXPR:
2521 case POSTDECREMENT_EXPR:
2524 case POSTINCREMENT_EXPR:
2534 return "<<< ??? >>>";
2541 return op_symbol_1 (TREE_CODE (op));
2544 /* Prints the name of a CALL_EXPR. */
2547 print_call_name (pretty_printer *buffer, tree node)
2551 gcc_assert (TREE_CODE (node) == CALL_EXPR);
2553 op0 = CALL_EXPR_FN (node);
2555 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2556 op0 = TREE_OPERAND (op0, 0);
2558 switch (TREE_CODE (op0))
2562 dump_function_name (buffer, op0);
2568 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2572 pp_string (buffer, "(");
2573 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2574 pp_string (buffer, ") ? ");
2575 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
2576 pp_string (buffer, " : ");
2577 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
2581 /* The function is a pointer contained in a structure. */
2582 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
2583 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2584 dump_function_name (buffer, TREE_OPERAND (op0, 1));
2586 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2588 We can have several levels of structures and a function
2589 pointer inside. This is not implemented yet... */
2594 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2595 dump_function_name (buffer, TREE_OPERAND (op0, 0));
2597 dump_generic_node (buffer, op0, 0, 0, false);
2602 dump_generic_node (buffer, op0, 0, 0, false);
2610 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2613 pretty_print_string (pretty_printer *buffer, const char *str)
2623 pp_string (buffer, "\\b");
2627 pp_string (buffer, "\\f");
2631 pp_string (buffer, "\\n");
2635 pp_string (buffer, "\\r");
2639 pp_string (buffer, "\\t");
2643 pp_string (buffer, "\\v");
2647 pp_string (buffer, "\\\\");
2651 pp_string (buffer, "\\\"");
2655 pp_string (buffer, "\\'");
2658 /* No need to handle \0; the loop terminates on \0. */
2661 pp_string (buffer, "\\1");
2665 pp_string (buffer, "\\2");
2669 pp_string (buffer, "\\3");
2673 pp_string (buffer, "\\4");
2677 pp_string (buffer, "\\5");
2681 pp_string (buffer, "\\6");
2685 pp_string (buffer, "\\7");
2689 pp_character (buffer, str[0]);
2697 maybe_init_pretty_print (FILE *file)
2701 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2702 pp_needs_newline (&buffer) = true;
2706 buffer.buffer->stream = file;
2710 newline_and_indent (pretty_printer *buffer, int spc)
2712 pp_newline (buffer);
2718 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2720 struct voptype_d *vdefs;
2721 struct voptype_d *vuses;
2724 if (!ssa_operands_active () || !stmt_references_memory_p (stmt))
2727 /* Even if the statement doesn't have virtual operators yet, it may
2728 contain symbol information (this happens before aliases have been
2730 if ((flags & TDF_MEMSYMS)
2731 && VUSE_OPS (stmt) == NULL
2732 && VDEF_OPS (stmt) == NULL)
2734 if (LOADED_SYMS (stmt))
2736 pp_string (buffer, "# LOADS: ");
2737 dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2738 newline_and_indent (buffer, spc);
2741 if (STORED_SYMS (stmt))
2743 pp_string (buffer, "# STORES: ");
2744 dump_symbols (buffer, STORED_SYMS (stmt), flags);
2745 newline_and_indent (buffer, spc);
2751 vuses = VUSE_OPS (stmt);
2754 pp_string (buffer, "# VUSE <");
2756 n = VUSE_NUM (vuses);
2757 for (i = 0; i < n; i++)
2759 dump_generic_node (buffer, VUSE_OP (vuses, i), spc + 2, flags, false);
2761 pp_string (buffer, ", ");
2764 pp_string (buffer, ">");
2766 if (flags & TDF_MEMSYMS)
2767 dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2769 newline_and_indent (buffer, spc);
2770 vuses = vuses->next;
2773 vdefs = VDEF_OPS (stmt);
2776 pp_string (buffer, "# ");
2777 dump_generic_node (buffer, VDEF_RESULT (vdefs), spc + 2, flags, false);
2778 pp_string (buffer, " = VDEF <");
2780 n = VDEF_NUM (vdefs);
2781 for (i = 0; i < n; i++)
2783 dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, 0);
2785 pp_string (buffer, ", ");
2788 pp_string (buffer, ">");
2790 if ((flags & TDF_MEMSYMS) && vdefs->next == NULL)
2791 dump_symbols (buffer, STORED_SYMS (stmt), flags);
2793 newline_and_indent (buffer, spc);
2794 vdefs = vdefs->next;
2799 /* Dumps basic block BB to FILE with details described by FLAGS and
2800 indented by INDENT spaces. */
2803 dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2805 maybe_init_pretty_print (file);
2806 dump_generic_bb_buff (&buffer, bb, indent, flags);
2810 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2811 spaces and details described by flags. */
2814 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2820 if (flags & TDF_BLOCKS)
2823 pp_string (buffer, "# BLOCK ");
2824 pp_decimal_int (buffer, bb->index);
2827 pp_string (buffer, " freq:");
2828 pp_decimal_int (buffer, bb->frequency);
2832 pp_string (buffer, " count:");
2833 pp_widest_integer (buffer, bb->count);
2836 if (flags & TDF_LINENO)
2838 block_stmt_iterator bsi;
2840 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2841 if (get_lineno (bsi_stmt (bsi)) != -1)
2843 pp_string (buffer, ", starting at line ");
2844 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2848 newline_and_indent (buffer, indent);
2850 pp_string (buffer, "# PRED:");
2851 pp_write_text_to_stream (buffer);
2852 FOR_EACH_EDGE (e, ei, bb->preds)
2853 if (flags & TDF_SLIM)
2855 pp_string (buffer, " ");
2856 if (e->src == ENTRY_BLOCK_PTR)
2857 pp_string (buffer, "ENTRY");
2859 pp_decimal_int (buffer, e->src->index);
2862 dump_edge_info (buffer->buffer->stream, e, 0);
2863 pp_newline (buffer);
2867 stmt = first_stmt (bb);
2868 if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
2870 INDENT (indent - 2);
2871 pp_string (buffer, "<bb ");
2872 pp_decimal_int (buffer, bb->index);
2873 pp_string (buffer, ">:");
2874 pp_newline (buffer);
2877 pp_write_text_to_stream (buffer);
2878 check_bb_profile (bb, buffer->buffer->stream);
2881 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2885 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
2891 pp_string (buffer, "# SUCC:");
2892 pp_write_text_to_stream (buffer);
2893 FOR_EACH_EDGE (e, ei, bb->succs)
2894 if (flags & TDF_SLIM)
2896 pp_string (buffer, " ");
2897 if (e->dest == EXIT_BLOCK_PTR)
2898 pp_string (buffer, "EXIT");
2900 pp_decimal_int (buffer, e->dest->index);
2903 dump_edge_info (buffer->buffer->stream, e, 1);
2904 pp_newline (buffer);
2907 /* Dump PHI nodes of basic block BB to BUFFER with details described
2908 by FLAGS and indented by INDENT spaces. */
2911 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
2913 tree phi = phi_nodes (bb);
2917 for (; phi; phi = PHI_CHAIN (phi))
2919 if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
2922 pp_string (buffer, "# ");
2923 dump_generic_node (buffer, phi, indent, flags, false);
2924 pp_newline (buffer);
2930 /* Dump jump to basic block BB that is represented implicitly in the cfg
2934 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
2938 stmt = first_stmt (bb);
2940 pp_string (buffer, "goto <bb ");
2941 pp_decimal_int (buffer, bb->index);
2942 pp_string (buffer, ">");
2943 if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
2945 pp_string (buffer, " (");
2946 dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
2947 pp_string (buffer, ")");
2949 pp_semicolon (buffer);
2952 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
2953 by INDENT spaces, with details given by FLAGS. */
2956 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
2963 stmt = last_stmt (bb);
2964 if (stmt && TREE_CODE (stmt) == COND_EXPR)
2966 edge true_edge, false_edge;
2968 /* When we are emitting the code or changing CFG, it is possible that
2969 the edges are not yet created. When we are using debug_bb in such
2970 a situation, we do not want it to crash. */
2971 if (EDGE_COUNT (bb->succs) != 2)
2973 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
2975 INDENT (indent + 2);
2976 pp_cfg_jump (buffer, true_edge->dest);
2977 newline_and_indent (buffer, indent);
2978 pp_string (buffer, "else");
2979 newline_and_indent (buffer, indent + 2);
2980 pp_cfg_jump (buffer, false_edge->dest);
2981 pp_newline (buffer);
2985 /* If there is a fallthru edge, we may need to add an artificial goto to the
2987 FOR_EACH_EDGE (e, ei, bb->succs)
2988 if (e->flags & EDGE_FALLTHRU)
2990 if (e && e->dest != bb->next_bb)
2994 if ((flags & TDF_LINENO)
2995 #ifdef USE_MAPPED_LOCATION
2996 && e->goto_locus != UNKNOWN_LOCATION
3002 expanded_location goto_xloc;
3003 #ifdef USE_MAPPED_LOCATION
3004 goto_xloc = expand_location (e->goto_locus);
3006 goto_xloc = *e->goto_locus;
3008 pp_character (buffer, '[');
3011 pp_string (buffer, goto_xloc.file);
3012 pp_string (buffer, " : ");
3014 pp_decimal_int (buffer, goto_xloc.line);
3015 pp_string (buffer, "] ");
3018 pp_cfg_jump (buffer, e->dest);
3019 pp_newline (buffer);
3023 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
3024 indented by INDENT spaces. */
3027 dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
3028 int indent, int flags)
3030 block_stmt_iterator bsi;
3032 int label_indent = indent - 2;
3034 if (label_indent < 0)
3037 dump_bb_header (buffer, bb, indent, flags);
3039 dump_phi_nodes (buffer, bb, indent, flags);
3041 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
3045 stmt = bsi_stmt (bsi);
3047 curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
3049 INDENT (curr_indent);
3050 dump_generic_node (buffer, stmt, curr_indent, flags, true);
3051 pp_newline (buffer);
3052 dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
3055 dump_implicit_edges (buffer, bb, indent, flags);
3057 if (flags & TDF_BLOCKS)
3058 dump_bb_end (buffer, bb, indent, flags);