1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
28 #include "diagnostic.h"
31 #include "tree-flow.h"
32 #include "langhooks.h"
33 #include "tree-iterator.h"
34 #include "tree-chrec.h"
35 #include "tree-pass.h"
36 #include "fixed-value.h"
37 #include "value-prof.h"
40 /* Local functions, macros and variables. */
41 static const char *op_symbol (const_tree);
42 static void pretty_print_string (pretty_printer *, const char*);
43 static void print_call_name (pretty_printer *, const_tree);
44 static void newline_and_indent (pretty_printer *, int);
45 static void maybe_init_pretty_print (FILE *);
46 static void print_struct_decl (pretty_printer *, const_tree, int, int);
47 static void do_niy (pretty_printer *, const_tree);
49 #define INDENT(SPACE) do { \
50 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
52 #define NIY do_niy(buffer,node)
54 #define PRINT_FUNCTION_NAME(NODE) pp_printf \
55 (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \
56 lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
57 lang_hooks.decl_printable_name (NODE, 1))
59 static pretty_printer buffer;
60 static int initialized = 0;
62 /* Try to print something for an unknown tree code. */
65 do_niy (pretty_printer *buffer, const_tree node)
69 pp_string (buffer, "<<< Unknown tree: ");
70 pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
74 len = TREE_OPERAND_LENGTH (node);
75 for (i = 0; i < len; ++i)
77 newline_and_indent (buffer, 2);
78 dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);
82 pp_string (buffer, " >>>\n");
85 /* Debugging function to print out a generic expression. */
88 debug_generic_expr (tree t)
90 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
91 fprintf (stderr, "\n");
94 /* Debugging function to print out a generic statement. */
97 debug_generic_stmt (tree t)
99 print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
100 fprintf (stderr, "\n");
103 /* Debugging function to print out a chain of trees . */
106 debug_tree_chain (tree t)
110 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
111 fprintf(stderr, " ");
114 fprintf (stderr, "\n");
117 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
119 print_generic_decl (FILE *file, tree decl, int flags)
121 maybe_init_pretty_print (file);
122 print_declaration (&buffer, decl, 2, flags);
123 pp_write_text_to_stream (&buffer);
126 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
127 to show in the dump. See TDF_* in tree-pass.h. */
130 print_generic_stmt (FILE *file, tree t, int flags)
132 maybe_init_pretty_print (file);
133 dump_generic_node (&buffer, t, 0, flags, true);
137 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
138 to show in the dump. See TDF_* in tree-pass.h. The output is indented by
142 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
146 maybe_init_pretty_print (file);
148 for (i = 0; i < indent; i++)
150 dump_generic_node (&buffer, t, indent, flags, true);
154 /* Print a single expression T on file FILE. FLAGS specifies details to show
155 in the dump. See TDF_* in tree-pass.h. */
158 print_generic_expr (FILE *file, tree t, int flags)
160 maybe_init_pretty_print (file);
161 dump_generic_node (&buffer, t, 0, flags, false);
164 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
168 dump_decl_name (pretty_printer *buffer, tree node, int flags)
173 pp_tree_identifier (buffer, DECL_NAME (t));
174 if ((flags & TDF_UID)
175 || DECL_NAME (t) == NULL_TREE)
177 if (TREE_CODE (t) == LABEL_DECL
178 && LABEL_DECL_UID (t) != -1)
179 pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (t));
182 char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
183 pp_printf (buffer, "%c.%u", c, DECL_UID (t));
188 /* Like the above, but used for pretty printing function calls. */
191 dump_function_name (pretty_printer *buffer, tree node)
193 if (DECL_NAME (node))
194 PRINT_FUNCTION_NAME (node);
196 dump_decl_name (buffer, node, 0);
199 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
200 FLAGS are as in dump_generic_node. */
203 dump_function_declaration (pretty_printer *buffer, tree node,
206 bool wrote_arg = false;
210 pp_character (buffer, '(');
212 /* Print the argument types. The last element in the list is a VOID_TYPE.
213 The following avoids printing the last element. */
214 arg = TYPE_ARG_TYPES (node);
215 while (arg && TREE_CHAIN (arg) && arg != error_mark_node)
218 dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
219 arg = TREE_CHAIN (arg);
220 if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)
222 pp_character (buffer, ',');
228 pp_string (buffer, "void");
230 pp_character (buffer, ')');
233 /* Dump the domain associated with an array. */
236 dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
238 pp_character (buffer, '[');
241 tree min = TYPE_MIN_VALUE (domain);
242 tree max = TYPE_MAX_VALUE (domain);
245 && integer_zerop (min)
246 && host_integerp (max, 0))
247 pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
251 dump_generic_node (buffer, min, spc, flags, false);
252 pp_character (buffer, ':');
254 dump_generic_node (buffer, max, spc, flags, false);
258 pp_string (buffer, "<unknown>");
259 pp_character (buffer, ']');
263 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
264 dump_generic_node. */
267 dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
271 switch (OMP_CLAUSE_CODE (clause))
273 case OMP_CLAUSE_PRIVATE:
276 case OMP_CLAUSE_SHARED:
279 case OMP_CLAUSE_FIRSTPRIVATE:
280 name = "firstprivate";
282 case OMP_CLAUSE_LASTPRIVATE:
283 name = "lastprivate";
285 case OMP_CLAUSE_COPYIN:
288 case OMP_CLAUSE_COPYPRIVATE:
289 name = "copyprivate";
292 pp_string (buffer, name);
293 pp_character (buffer, '(');
294 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
296 pp_character (buffer, ')');
299 case OMP_CLAUSE_REDUCTION:
300 pp_string (buffer, "reduction(");
301 pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
302 pp_character (buffer, ':');
303 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
305 pp_character (buffer, ')');
309 pp_string (buffer, "if(");
310 dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
312 pp_character (buffer, ')');
315 case OMP_CLAUSE_NUM_THREADS:
316 pp_string (buffer, "num_threads(");
317 dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
319 pp_character (buffer, ')');
322 case OMP_CLAUSE_NOWAIT:
323 pp_string (buffer, "nowait");
325 case OMP_CLAUSE_ORDERED:
326 pp_string (buffer, "ordered");
329 case OMP_CLAUSE_DEFAULT:
330 pp_string (buffer, "default(");
331 switch (OMP_CLAUSE_DEFAULT_KIND (clause))
333 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
335 case OMP_CLAUSE_DEFAULT_SHARED:
336 pp_string (buffer, "shared");
338 case OMP_CLAUSE_DEFAULT_NONE:
339 pp_string (buffer, "none");
341 case OMP_CLAUSE_DEFAULT_PRIVATE:
342 pp_string (buffer, "private");
344 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
345 pp_string (buffer, "firstprivate");
350 pp_character (buffer, ')');
353 case OMP_CLAUSE_SCHEDULE:
354 pp_string (buffer, "schedule(");
355 switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
357 case OMP_CLAUSE_SCHEDULE_STATIC:
358 pp_string (buffer, "static");
360 case OMP_CLAUSE_SCHEDULE_DYNAMIC:
361 pp_string (buffer, "dynamic");
363 case OMP_CLAUSE_SCHEDULE_GUIDED:
364 pp_string (buffer, "guided");
366 case OMP_CLAUSE_SCHEDULE_RUNTIME:
367 pp_string (buffer, "runtime");
369 case OMP_CLAUSE_SCHEDULE_AUTO:
370 pp_string (buffer, "auto");
375 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
377 pp_character (buffer, ',');
378 dump_generic_node (buffer,
379 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
382 pp_character (buffer, ')');
385 case OMP_CLAUSE_UNTIED:
386 pp_string (buffer, "untied");
389 case OMP_CLAUSE_COLLAPSE:
390 pp_string (buffer, "collapse(");
391 dump_generic_node (buffer,
392 OMP_CLAUSE_COLLAPSE_EXPR (clause),
394 pp_character (buffer, ')');
398 /* Should never happen. */
399 dump_generic_node (buffer, clause, spc, flags, false);
405 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
406 dump_generic_node. */
409 dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
417 dump_omp_clause (buffer, clause, spc, flags);
418 clause = OMP_CLAUSE_CHAIN (clause);
426 /* Dump location LOC to BUFFER. */
429 dump_location (pretty_printer *buffer, location_t loc)
431 expanded_location xloc = expand_location (loc);
433 pp_character (buffer, '[');
436 pp_string (buffer, xloc.file);
437 pp_string (buffer, " : ");
439 pp_decimal_int (buffer, xloc.line);
440 pp_string (buffer, "] ");
444 /* Dump lexical block BLOCK. BUFFER, SPC and FLAGS are as in
445 dump_generic_node. */
448 dump_block_node (pretty_printer *buffer, tree block, int spc, int flags)
452 pp_printf (buffer, "BLOCK #%d ", BLOCK_NUMBER (block));
454 if (flags & TDF_ADDRESS)
455 pp_printf (buffer, "[%p] ", (void *) block);
457 if (BLOCK_ABSTRACT (block))
458 pp_string (buffer, "[abstract] ");
460 if (TREE_ASM_WRITTEN (block))
461 pp_string (buffer, "[written] ");
463 if (flags & TDF_SLIM)
466 if (BLOCK_SOURCE_LOCATION (block))
467 dump_location (buffer, BLOCK_SOURCE_LOCATION (block));
469 newline_and_indent (buffer, spc + 2);
471 if (BLOCK_SUPERCONTEXT (block))
473 pp_string (buffer, "SUPERCONTEXT: ");
474 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (block), 0,
475 flags | TDF_SLIM, false);
476 newline_and_indent (buffer, spc + 2);
479 if (BLOCK_SUBBLOCKS (block))
481 pp_string (buffer, "SUBBLOCKS: ");
482 for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
484 dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
485 pp_string (buffer, " ");
487 newline_and_indent (buffer, spc + 2);
490 if (BLOCK_CHAIN (block))
492 pp_string (buffer, "SIBLINGS: ");
493 for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))
495 dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
496 pp_string (buffer, " ");
498 newline_and_indent (buffer, spc + 2);
501 if (BLOCK_VARS (block))
503 pp_string (buffer, "VARS: ");
504 for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
506 dump_generic_node (buffer, t, 0, flags, false);
507 pp_string (buffer, " ");
509 newline_and_indent (buffer, spc + 2);
512 if (VEC_length (tree, BLOCK_NONLOCALIZED_VARS (block)) > 0)
515 VEC(tree,gc) *nlv = BLOCK_NONLOCALIZED_VARS (block);
517 pp_string (buffer, "NONLOCALIZED_VARS: ");
518 for (i = 0; VEC_iterate (tree, nlv, i, t); i++)
520 dump_generic_node (buffer, t, 0, flags, false);
521 pp_string (buffer, " ");
523 newline_and_indent (buffer, spc + 2);
526 if (BLOCK_ABSTRACT_ORIGIN (block))
528 pp_string (buffer, "ABSTRACT_ORIGIN: ");
529 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (block), 0,
530 flags | TDF_SLIM, false);
531 newline_and_indent (buffer, spc + 2);
534 if (BLOCK_FRAGMENT_ORIGIN (block))
536 pp_string (buffer, "FRAGMENT_ORIGIN: ");
537 dump_generic_node (buffer, BLOCK_FRAGMENT_ORIGIN (block), 0,
538 flags | TDF_SLIM, false);
539 newline_and_indent (buffer, spc + 2);
542 if (BLOCK_FRAGMENT_CHAIN (block))
544 pp_string (buffer, "FRAGMENT_CHAIN: ");
545 for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))
547 dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
548 pp_string (buffer, " ");
550 newline_and_indent (buffer, spc + 2);
555 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
556 indent. FLAGS specifies details to show in the dump (see TDF_* in
557 tree-pass.h). If IS_STMT is true, the object printed is considered
558 to be a statement and it is terminated by ';' if appropriate. */
561 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
569 if (node == NULL_TREE)
572 is_expr = EXPR_P (node);
574 if (is_stmt && (flags & TDF_STMTADDR))
575 pp_printf (buffer, "<&%p> ", (void *)node);
577 if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
578 dump_location (buffer, EXPR_LOCATION (node));
580 switch (TREE_CODE (node))
583 pp_string (buffer, "<<< error >>>");
586 case IDENTIFIER_NODE:
587 pp_tree_identifier (buffer, node);
591 while (node && node != error_mark_node)
593 if (TREE_PURPOSE (node))
595 dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
598 dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
599 node = TREE_CHAIN (node);
600 if (node && TREE_CODE (node) == TREE_LIST)
602 pp_character (buffer, ',');
609 dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
615 if (TREE_VEC_LENGTH (node) > 0)
617 size_t len = TREE_VEC_LENGTH (node);
618 for (i = 0; i < len - 1; i++)
620 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
622 pp_character (buffer, ',');
625 dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
634 case FIXED_POINT_TYPE:
640 unsigned int quals = TYPE_QUALS (node);
641 enum tree_code_class tclass;
643 if (quals & TYPE_QUAL_CONST)
644 pp_string (buffer, "const ");
645 else if (quals & TYPE_QUAL_VOLATILE)
646 pp_string (buffer, "volatile ");
647 else if (quals & TYPE_QUAL_RESTRICT)
648 pp_string (buffer, "restrict ");
650 tclass = TREE_CODE_CLASS (TREE_CODE (node));
652 if (tclass == tcc_declaration)
654 if (DECL_NAME (node))
655 dump_decl_name (buffer, node, flags);
657 pp_string (buffer, "<unnamed type decl>");
659 else if (tclass == tcc_type)
661 if (TYPE_NAME (node))
663 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
664 pp_tree_identifier (buffer, TYPE_NAME (node));
665 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
666 && DECL_NAME (TYPE_NAME (node)))
667 dump_decl_name (buffer, TYPE_NAME (node), flags);
669 pp_string (buffer, "<unnamed type>");
671 else if (TREE_CODE (node) == VECTOR_TYPE)
673 pp_string (buffer, "vector ");
674 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
676 else if (TREE_CODE (node) == INTEGER_TYPE)
678 pp_string (buffer, (TYPE_UNSIGNED (node)
679 ? "<unnamed-unsigned:"
680 : "<unnamed-signed:"));
681 pp_decimal_int (buffer, TYPE_PRECISION (node));
682 pp_string (buffer, ">");
684 else if (TREE_CODE (node) == COMPLEX_TYPE)
686 pp_string (buffer, "__complex__ ");
687 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
689 else if (TREE_CODE (node) == REAL_TYPE)
691 pp_string (buffer, "<float:");
692 pp_decimal_int (buffer, TYPE_PRECISION (node));
693 pp_string (buffer, ">");
695 else if (TREE_CODE (node) == FIXED_POINT_TYPE)
697 pp_string (buffer, "<fixed-point-");
698 pp_string (buffer, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
699 pp_decimal_int (buffer, TYPE_PRECISION (node));
700 pp_string (buffer, ">");
703 pp_string (buffer, "<unnamed type>");
710 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
712 if (TREE_TYPE (node) == NULL)
714 pp_string (buffer, str);
715 pp_string (buffer, "<null type>");
717 else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
719 tree fnode = TREE_TYPE (node);
721 dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
723 pp_character (buffer, '(');
724 pp_string (buffer, str);
725 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
726 dump_decl_name (buffer, TYPE_NAME (node), flags);
728 pp_printf (buffer, "<T%x>", TYPE_UID (node));
730 pp_character (buffer, ')');
731 dump_function_declaration (buffer, fnode, spc, flags);
735 unsigned int quals = TYPE_QUALS (node);
737 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
739 pp_string (buffer, str);
741 if (quals & TYPE_QUAL_CONST)
742 pp_string (buffer, " const");
743 if (quals & TYPE_QUAL_VOLATILE)
744 pp_string (buffer, " volatile");
745 if (quals & TYPE_QUAL_RESTRICT)
746 pp_string (buffer, " restrict");
748 if (TYPE_REF_CAN_ALIAS_ALL (node))
749 pp_string (buffer, " {ref-all}");
759 const char *sep = "";
762 pp_string (buffer, "MEM[");
764 tmp = TMR_SYMBOL (node);
767 pp_string (buffer, sep);
769 pp_string (buffer, "symbol: ");
770 dump_generic_node (buffer, tmp, spc, flags, false);
772 tmp = TMR_BASE (node);
775 pp_string (buffer, sep);
777 pp_string (buffer, "base: ");
778 dump_generic_node (buffer, tmp, spc, flags, false);
780 tmp = TMR_INDEX (node);
783 pp_string (buffer, sep);
785 pp_string (buffer, "index: ");
786 dump_generic_node (buffer, tmp, spc, flags, false);
788 tmp = TMR_STEP (node);
791 pp_string (buffer, sep);
793 pp_string (buffer, "step: ");
794 dump_generic_node (buffer, tmp, spc, flags, false);
796 tmp = TMR_OFFSET (node);
799 pp_string (buffer, sep);
801 pp_string (buffer, "offset: ");
802 dump_generic_node (buffer, tmp, spc, flags, false);
804 pp_string (buffer, "]");
805 if (flags & TDF_DETAILS)
807 pp_string (buffer, "{");
808 dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,
810 pp_string (buffer, "}");
819 /* Print the innermost component type. */
820 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
821 tmp = TREE_TYPE (tmp))
823 dump_generic_node (buffer, tmp, spc, flags, false);
825 /* Print the dimensions. */
826 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
827 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
833 case QUAL_UNION_TYPE:
835 unsigned int quals = TYPE_QUALS (node);
837 if (quals & TYPE_QUAL_CONST)
838 pp_string (buffer, "const ");
839 if (quals & TYPE_QUAL_VOLATILE)
840 pp_string (buffer, "volatile ");
842 /* Print the name of the structure. */
843 if (TREE_CODE (node) == RECORD_TYPE)
844 pp_string (buffer, "struct ");
845 else if (TREE_CODE (node) == UNION_TYPE)
846 pp_string (buffer, "union ");
848 if (TYPE_NAME (node))
849 dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
850 else if (!(flags & TDF_SLIM))
851 /* FIXME: If we eliminate the 'else' above and attempt
852 to show the fields for named types, we may get stuck
853 following a cycle of pointers to structs. The alleged
854 self-reference check in print_struct_decl will not detect
855 cycles involving more than one pointer or struct type. */
856 print_struct_decl (buffer, node, spc, flags);
865 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
867 /* In the case of a pointer, one may want to divide by the
868 size of the pointed-to type. Unfortunately, this not
869 straightforward. The C front-end maps expressions
874 in such a way that the two INTEGER_CST nodes for "5" have
875 different values but identical types. In the latter
876 case, the 5 is multiplied by sizeof (int) in c-common.c
877 (pointer_int_sum) to convert it to a byte address, and
878 yet the type of the node is left unchanged. Argh. What
879 is consistent though is that the number value corresponds
880 to bytes (UNITS) offset.
882 NB: Neither of the following divisors can be trivially
883 used to recover the original literal:
885 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
886 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
887 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
888 pp_string (buffer, "B"); /* pseudo-unit */
890 else if (! host_integerp (node, 0))
893 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
894 HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);
896 if (tree_int_cst_sgn (val) < 0)
898 pp_character (buffer, '-');
902 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
904 sprintf (pp_buffer (buffer)->digit_buffer,
905 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
906 (unsigned HOST_WIDE_INT) high, low);
907 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
910 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
914 /* Code copied from print_node. */
917 if (TREE_OVERFLOW (node))
918 pp_string (buffer, " overflow");
920 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
921 d = TREE_REAL_CST (node);
922 if (REAL_VALUE_ISINF (d))
923 pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
924 else if (REAL_VALUE_ISNAN (d))
925 pp_string (buffer, " Nan");
929 real_to_decimal (string, &d, sizeof (string), 0, 1);
930 pp_string (buffer, string);
935 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
936 pp_string (buffer, "0x");
937 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
938 output_formatted_integer (buffer, "%02x", *p++);
947 fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
948 pp_string (buffer, string);
953 pp_string (buffer, "__complex__ (");
954 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
955 pp_string (buffer, ", ");
956 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
957 pp_string (buffer, ")");
961 pp_string (buffer, "\"");
962 pretty_print_string (buffer, TREE_STRING_POINTER (node));
963 pp_string (buffer, "\"");
969 pp_string (buffer, "{ ");
970 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
972 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
973 if (TREE_CHAIN (elt))
974 pp_string (buffer, ", ");
976 pp_string (buffer, " }");
982 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
984 if (TREE_CODE (node) == METHOD_TYPE)
986 if (TYPE_METHOD_BASETYPE (node))
987 dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
990 pp_string (buffer, "<null method basetype>");
991 pp_string (buffer, "::");
993 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
994 dump_decl_name (buffer, TYPE_NAME (node), flags);
996 pp_printf (buffer, "<T%x>", TYPE_UID (node));
997 dump_function_declaration (buffer, node, spc, flags);
1002 dump_decl_name (buffer, node, flags);
1006 if (DECL_NAME (node))
1007 dump_decl_name (buffer, node, flags);
1008 else if (LABEL_DECL_UID (node) != -1)
1009 pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));
1011 pp_printf (buffer, "<D.%u>", DECL_UID (node));
1015 if (DECL_IS_BUILTIN (node))
1017 /* Don't print the declaration of built-in types. */
1020 if (DECL_NAME (node))
1021 dump_decl_name (buffer, node, flags);
1024 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
1025 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
1026 && TYPE_METHODS (TREE_TYPE (node)))
1028 /* The type is a c++ class: all structures have at least
1030 pp_string (buffer, "class ");
1031 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1036 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
1037 ? "union" : "struct "));
1038 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1046 case NAMESPACE_DECL:
1047 dump_decl_name (buffer, node, flags);
1051 pp_string (buffer, "<retval>");
1055 op0 = TREE_OPERAND (node, 0);
1057 if (TREE_CODE (op0) == INDIRECT_REF)
1059 op0 = TREE_OPERAND (op0, 0);
1062 if (op_prio (op0) < op_prio (node))
1063 pp_character (buffer, '(');
1064 dump_generic_node (buffer, op0, spc, flags, false);
1065 if (op_prio (op0) < op_prio (node))
1066 pp_character (buffer, ')');
1067 pp_string (buffer, str);
1068 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1069 op0 = component_ref_field_offset (node);
1070 if (op0 && TREE_CODE (op0) != INTEGER_CST)
1072 pp_string (buffer, "{off: ");
1073 dump_generic_node (buffer, op0, spc, flags, false);
1074 pp_character (buffer, '}');
1079 pp_string (buffer, "BIT_FIELD_REF <");
1080 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1081 pp_string (buffer, ", ");
1082 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1083 pp_string (buffer, ", ");
1084 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1085 pp_string (buffer, ">");
1089 case ARRAY_RANGE_REF:
1090 op0 = TREE_OPERAND (node, 0);
1091 if (op_prio (op0) < op_prio (node))
1092 pp_character (buffer, '(');
1093 dump_generic_node (buffer, op0, spc, flags, false);
1094 if (op_prio (op0) < op_prio (node))
1095 pp_character (buffer, ')');
1096 pp_character (buffer, '[');
1097 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1098 if (TREE_CODE (node) == ARRAY_RANGE_REF)
1099 pp_string (buffer, " ...");
1100 pp_character (buffer, ']');
1102 op0 = array_ref_low_bound (node);
1103 op1 = array_ref_element_size (node);
1105 if (!integer_zerop (op0)
1106 || TREE_OPERAND (node, 2)
1107 || TREE_OPERAND (node, 3))
1109 pp_string (buffer, "{lb: ");
1110 dump_generic_node (buffer, op0, spc, flags, false);
1111 pp_string (buffer, " sz: ");
1112 dump_generic_node (buffer, op1, spc, flags, false);
1113 pp_character (buffer, '}');
1119 unsigned HOST_WIDE_INT ix;
1121 bool is_struct_init = FALSE;
1122 pp_character (buffer, '{');
1123 if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
1124 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
1125 is_struct_init = TRUE;
1126 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
1128 if (field && is_struct_init)
1130 pp_character (buffer, '.');
1131 dump_generic_node (buffer, field, spc, flags, false);
1132 pp_string (buffer, "=");
1134 if (val && TREE_CODE (val) == ADDR_EXPR)
1135 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
1136 val = TREE_OPERAND (val, 0);
1137 if (val && TREE_CODE (val) == FUNCTION_DECL)
1138 dump_decl_name (buffer, val, flags);
1140 dump_generic_node (buffer, val, spc, flags, false);
1141 if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
1143 pp_character (buffer, ',');
1147 pp_character (buffer, '}');
1154 if (flags & TDF_SLIM)
1156 pp_string (buffer, "<COMPOUND_EXPR>");
1160 dump_generic_node (buffer, TREE_OPERAND (node, 0),
1161 spc, flags, !(flags & TDF_SLIM));
1162 if (flags & TDF_SLIM)
1163 newline_and_indent (buffer, spc);
1166 pp_character (buffer, ',');
1170 for (tp = &TREE_OPERAND (node, 1);
1171 TREE_CODE (*tp) == COMPOUND_EXPR;
1172 tp = &TREE_OPERAND (*tp, 1))
1174 dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
1175 spc, flags, !(flags & TDF_SLIM));
1176 if (flags & TDF_SLIM)
1177 newline_and_indent (buffer, spc);
1180 pp_character (buffer, ',');
1185 dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
1189 case STATEMENT_LIST:
1191 tree_stmt_iterator si;
1194 if (flags & TDF_SLIM)
1196 pp_string (buffer, "<STATEMENT_LIST>");
1200 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1203 newline_and_indent (buffer, spc);
1206 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
1213 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags,
1216 pp_character (buffer, '=');
1217 if (TREE_CODE (node) == MODIFY_EXPR
1218 && MOVE_NONTEMPORAL (node))
1219 pp_string (buffer, "{nt}");
1221 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags,
1226 pp_string (buffer, "TARGET_EXPR <");
1227 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1228 pp_character (buffer, ',');
1230 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
1231 pp_character (buffer, '>');
1235 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1240 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1242 pp_string (buffer, "if (");
1243 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1244 pp_character (buffer, ')');
1245 /* The lowered cond_exprs should always be printed in full. */
1246 if (COND_EXPR_THEN (node)
1247 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1248 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1249 && COND_EXPR_ELSE (node)
1250 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1251 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1254 dump_generic_node (buffer, COND_EXPR_THEN (node),
1256 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1258 pp_string (buffer, " else ");
1259 dump_generic_node (buffer, COND_EXPR_ELSE (node),
1263 else if (!(flags & TDF_SLIM))
1265 /* Output COND_EXPR_THEN. */
1266 if (COND_EXPR_THEN (node))
1268 newline_and_indent (buffer, spc+2);
1269 pp_character (buffer, '{');
1270 newline_and_indent (buffer, spc+4);
1271 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1273 newline_and_indent (buffer, spc+2);
1274 pp_character (buffer, '}');
1277 /* Output COND_EXPR_ELSE. */
1278 if (COND_EXPR_ELSE (node)
1279 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1281 newline_and_indent (buffer, spc);
1282 pp_string (buffer, "else");
1283 newline_and_indent (buffer, spc+2);
1284 pp_character (buffer, '{');
1285 newline_and_indent (buffer, spc+4);
1286 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1288 newline_and_indent (buffer, spc+2);
1289 pp_character (buffer, '}');
1296 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1298 pp_character (buffer, '?');
1300 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1302 pp_character (buffer, ':');
1304 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1309 pp_character (buffer, '{');
1310 if (!(flags & TDF_SLIM))
1312 if (BIND_EXPR_VARS (node))
1314 pp_newline (buffer);
1316 for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
1318 print_declaration (buffer, op0, spc+2, flags);
1319 pp_newline (buffer);
1323 newline_and_indent (buffer, spc+2);
1324 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1325 newline_and_indent (buffer, spc);
1326 pp_character (buffer, '}');
1332 print_call_name (buffer, node);
1334 /* Print parameters. */
1336 pp_character (buffer, '(');
1339 call_expr_arg_iterator iter;
1340 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
1342 dump_generic_node (buffer, arg, spc, flags, false);
1343 if (more_call_expr_args_p (&iter))
1345 pp_character (buffer, ',');
1350 if (CALL_EXPR_VA_ARG_PACK (node))
1352 if (call_expr_nargs (node) > 0)
1354 pp_character (buffer, ',');
1357 pp_string (buffer, "__builtin_va_arg_pack ()");
1359 pp_character (buffer, ')');
1361 op1 = CALL_EXPR_STATIC_CHAIN (node);
1364 pp_string (buffer, " [static-chain: ");
1365 dump_generic_node (buffer, op1, spc, flags, false);
1366 pp_character (buffer, ']');
1369 if (CALL_EXPR_RETURN_SLOT_OPT (node))
1370 pp_string (buffer, " [return slot optimization]");
1371 if (CALL_EXPR_TAILCALL (node))
1372 pp_string (buffer, " [tail call]");
1375 case WITH_CLEANUP_EXPR:
1379 case CLEANUP_POINT_EXPR:
1380 pp_string (buffer, "<<cleanup_point ");
1381 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1382 pp_string (buffer, ">>");
1385 case PLACEHOLDER_EXPR:
1386 pp_string (buffer, "<PLACEHOLDER_EXPR ");
1387 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1388 pp_character (buffer, '>');
1391 /* Binary arithmetic and logic expressions. */
1392 case WIDEN_SUM_EXPR:
1393 case WIDEN_MULT_EXPR:
1396 case POINTER_PLUS_EXPR:
1398 case TRUNC_DIV_EXPR:
1400 case FLOOR_DIV_EXPR:
1401 case ROUND_DIV_EXPR:
1402 case TRUNC_MOD_EXPR:
1404 case FLOOR_MOD_EXPR:
1405 case ROUND_MOD_EXPR:
1407 case EXACT_DIV_EXPR:
1412 case VEC_LSHIFT_EXPR:
1413 case VEC_RSHIFT_EXPR:
1417 case TRUTH_ANDIF_EXPR:
1418 case TRUTH_ORIF_EXPR:
1419 case TRUTH_AND_EXPR:
1421 case TRUTH_XOR_EXPR:
1435 case UNORDERED_EXPR:
1437 const char *op = op_symbol (node);
1438 op0 = TREE_OPERAND (node, 0);
1439 op1 = TREE_OPERAND (node, 1);
1441 /* When the operands are expressions with less priority,
1442 keep semantics of the tree representation. */
1443 if (op_prio (op0) <= op_prio (node))
1445 pp_character (buffer, '(');
1446 dump_generic_node (buffer, op0, spc, flags, false);
1447 pp_character (buffer, ')');
1450 dump_generic_node (buffer, op0, spc, flags, false);
1453 pp_string (buffer, op);
1456 /* When the operands are expressions with less priority,
1457 keep semantics of the tree representation. */
1458 if (op_prio (op1) <= op_prio (node))
1460 pp_character (buffer, '(');
1461 dump_generic_node (buffer, op1, spc, flags, false);
1462 pp_character (buffer, ')');
1465 dump_generic_node (buffer, op1, spc, flags, false);
1469 /* Unary arithmetic and logic expressions. */
1472 case TRUTH_NOT_EXPR:
1474 case PREDECREMENT_EXPR:
1475 case PREINCREMENT_EXPR:
1476 case ALIGN_INDIRECT_REF:
1477 case MISALIGNED_INDIRECT_REF:
1479 if (TREE_CODE (node) == ADDR_EXPR
1480 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1481 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1482 ; /* Do not output '&' for strings and function pointers. */
1484 pp_string (buffer, op_symbol (node));
1486 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1488 pp_character (buffer, '(');
1489 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1490 pp_character (buffer, ')');
1493 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1495 if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1497 pp_string (buffer, "{misalignment: ");
1498 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1499 pp_character (buffer, '}');
1503 case POSTDECREMENT_EXPR:
1504 case POSTINCREMENT_EXPR:
1505 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1507 pp_character (buffer, '(');
1508 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1509 pp_character (buffer, ')');
1512 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1513 pp_string (buffer, op_symbol (node));
1517 pp_string (buffer, "MIN_EXPR <");
1518 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1519 pp_string (buffer, ", ");
1520 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1521 pp_character (buffer, '>');
1525 pp_string (buffer, "MAX_EXPR <");
1526 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1527 pp_string (buffer, ", ");
1528 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1529 pp_character (buffer, '>');
1533 pp_string (buffer, "ABS_EXPR <");
1534 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1535 pp_character (buffer, '>');
1542 case FIXED_CONVERT_EXPR:
1543 case FIX_TRUNC_EXPR:
1546 type = TREE_TYPE (node);
1547 op0 = TREE_OPERAND (node, 0);
1548 if (type != TREE_TYPE (op0))
1550 pp_character (buffer, '(');
1551 dump_generic_node (buffer, type, spc, flags, false);
1552 pp_string (buffer, ") ");
1554 if (op_prio (op0) < op_prio (node))
1555 pp_character (buffer, '(');
1556 dump_generic_node (buffer, op0, spc, flags, false);
1557 if (op_prio (op0) < op_prio (node))
1558 pp_character (buffer, ')');
1561 case VIEW_CONVERT_EXPR:
1562 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1563 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1564 pp_string (buffer, ">(");
1565 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1566 pp_character (buffer, ')');
1570 pp_string (buffer, "((");
1571 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1572 pp_string (buffer, "))");
1575 case NON_LVALUE_EXPR:
1576 pp_string (buffer, "NON_LVALUE_EXPR <");
1577 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1578 pp_character (buffer, '>');
1582 pp_string (buffer, "SAVE_EXPR <");
1583 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1584 pp_character (buffer, '>');
1588 pp_string (buffer, "COMPLEX_EXPR <");
1589 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1590 pp_string (buffer, ", ");
1591 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1592 pp_string (buffer, ">");
1596 pp_string (buffer, "CONJ_EXPR <");
1597 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1598 pp_string (buffer, ">");
1602 pp_string (buffer, "REALPART_EXPR <");
1603 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1604 pp_string (buffer, ">");
1608 pp_string (buffer, "IMAGPART_EXPR <");
1609 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1610 pp_string (buffer, ">");
1614 pp_string (buffer, "VA_ARG_EXPR <");
1615 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1616 pp_string (buffer, ">");
1619 case TRY_FINALLY_EXPR:
1620 case TRY_CATCH_EXPR:
1621 pp_string (buffer, "try");
1622 newline_and_indent (buffer, spc+2);
1623 pp_string (buffer, "{");
1624 newline_and_indent (buffer, spc+4);
1625 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1626 newline_and_indent (buffer, spc+2);
1627 pp_string (buffer, "}");
1628 newline_and_indent (buffer, spc);
1630 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1631 newline_and_indent (buffer, spc+2);
1632 pp_string (buffer, "{");
1633 newline_and_indent (buffer, spc+4);
1634 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1635 newline_and_indent (buffer, spc+2);
1636 pp_string (buffer, "}");
1641 pp_string (buffer, "catch (");
1642 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1643 pp_string (buffer, ")");
1644 newline_and_indent (buffer, spc+2);
1645 pp_string (buffer, "{");
1646 newline_and_indent (buffer, spc+4);
1647 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1648 newline_and_indent (buffer, spc+2);
1649 pp_string (buffer, "}");
1653 case EH_FILTER_EXPR:
1654 pp_string (buffer, "<<<eh_filter (");
1655 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1656 pp_string (buffer, ")>>>");
1657 newline_and_indent (buffer, spc+2);
1658 pp_string (buffer, "{");
1659 newline_and_indent (buffer, spc+4);
1660 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1661 newline_and_indent (buffer, spc+2);
1662 pp_string (buffer, "}");
1667 op0 = TREE_OPERAND (node, 0);
1668 /* If this is for break or continue, don't bother printing it. */
1669 if (DECL_NAME (op0))
1671 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1672 if (strcmp (name, "break") == 0
1673 || strcmp (name, "continue") == 0)
1676 dump_generic_node (buffer, op0, spc, flags, false);
1677 pp_character (buffer, ':');
1678 if (DECL_NONLOCAL (op0))
1679 pp_string (buffer, " [non-local]");
1683 pp_string (buffer, "<<<exception object>>>");
1687 pp_string (buffer, "<<<filter object>>>");
1691 pp_string (buffer, "while (1)");
1692 if (!(flags & TDF_SLIM))
1694 newline_and_indent (buffer, spc+2);
1695 pp_character (buffer, '{');
1696 newline_and_indent (buffer, spc+4);
1697 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1698 newline_and_indent (buffer, spc+2);
1699 pp_character (buffer, '}');
1705 pp_string (buffer, "// predicted ");
1706 if (PREDICT_EXPR_OUTCOME (node))
1707 pp_string (buffer, "likely by ");
1709 pp_string (buffer, "unlikely by ");
1710 pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
1711 pp_string (buffer, " predictor.");
1715 pp_string (buffer, "return");
1716 op0 = TREE_OPERAND (node, 0);
1720 if (TREE_CODE (op0) == MODIFY_EXPR)
1721 dump_generic_node (buffer, TREE_OPERAND (op0, 1),
1724 dump_generic_node (buffer, op0, spc, flags, false);
1729 pp_string (buffer, "if (");
1730 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1731 pp_string (buffer, ") break");
1735 pp_string (buffer, "switch (");
1736 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1737 pp_character (buffer, ')');
1738 if (!(flags & TDF_SLIM))
1740 newline_and_indent (buffer, spc+2);
1741 pp_character (buffer, '{');
1742 if (SWITCH_BODY (node))
1744 newline_and_indent (buffer, spc+4);
1745 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1750 tree vec = SWITCH_LABELS (node);
1751 size_t i, n = TREE_VEC_LENGTH (vec);
1752 for (i = 0; i < n; ++i)
1754 tree elt = TREE_VEC_ELT (vec, i);
1755 newline_and_indent (buffer, spc+4);
1758 dump_generic_node (buffer, elt, spc+4, flags, false);
1759 pp_string (buffer, " goto ");
1760 dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1762 pp_semicolon (buffer);
1765 pp_string (buffer, "case ???: goto ???;");
1768 newline_and_indent (buffer, spc+2);
1769 pp_character (buffer, '}');
1775 op0 = GOTO_DESTINATION (node);
1776 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1778 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1779 if (strcmp (name, "break") == 0
1780 || strcmp (name, "continue") == 0)
1782 pp_string (buffer, name);
1786 pp_string (buffer, "goto ");
1787 dump_generic_node (buffer, op0, spc, flags, false);
1791 pp_string (buffer, "resx ");
1792 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1796 pp_string (buffer, "__asm__");
1797 if (ASM_VOLATILE_P (node))
1798 pp_string (buffer, " __volatile__");
1799 pp_character (buffer, '(');
1800 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1801 pp_character (buffer, ':');
1802 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1803 pp_character (buffer, ':');
1804 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1805 if (ASM_CLOBBERS (node))
1807 pp_character (buffer, ':');
1808 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1810 pp_string (buffer, ")");
1813 case CASE_LABEL_EXPR:
1814 if (CASE_LOW (node) && CASE_HIGH (node))
1816 pp_string (buffer, "case ");
1817 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1818 pp_string (buffer, " ... ");
1819 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1821 else if (CASE_LOW (node))
1823 pp_string (buffer, "case ");
1824 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1827 pp_string (buffer, "default");
1828 pp_character (buffer, ':');
1832 pp_string (buffer, "OBJ_TYPE_REF(");
1833 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1834 pp_character (buffer, ';');
1835 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1836 pp_character (buffer, '-');
1837 pp_character (buffer, '>');
1838 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1839 pp_character (buffer, ')');
1843 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1844 pp_string (buffer, "_");
1845 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1846 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1847 pp_string (buffer, "(ab)");
1848 else if (SSA_NAME_IS_DEFAULT_DEF (node))
1849 pp_string (buffer, "(D)");
1852 case WITH_SIZE_EXPR:
1853 pp_string (buffer, "WITH_SIZE_EXPR <");
1854 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1855 pp_string (buffer, ", ");
1856 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1857 pp_string (buffer, ">");
1861 pp_string (buffer, "ASSERT_EXPR <");
1862 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1863 pp_string (buffer, ", ");
1864 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1865 pp_string (buffer, ">");
1869 pp_string (buffer, "scev_known");
1872 case SCEV_NOT_KNOWN:
1873 pp_string (buffer, "scev_not_known");
1876 case POLYNOMIAL_CHREC:
1877 pp_string (buffer, "{");
1878 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1879 pp_string (buffer, ", +, ");
1880 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1881 pp_string (buffer, "}_");
1882 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1886 case REALIGN_LOAD_EXPR:
1887 pp_string (buffer, "REALIGN_LOAD <");
1888 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1889 pp_string (buffer, ", ");
1890 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1891 pp_string (buffer, ", ");
1892 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1893 pp_string (buffer, ">");
1897 pp_string (buffer, " VEC_COND_EXPR < ");
1898 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1899 pp_string (buffer, " , ");
1900 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1901 pp_string (buffer, " , ");
1902 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1903 pp_string (buffer, " > ");
1907 pp_string (buffer, " DOT_PROD_EXPR < ");
1908 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1909 pp_string (buffer, ", ");
1910 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1911 pp_string (buffer, ", ");
1912 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1913 pp_string (buffer, " > ");
1917 pp_string (buffer, "#pragma omp parallel");
1918 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
1921 if (!(flags & TDF_SLIM) && OMP_BODY (node))
1923 newline_and_indent (buffer, spc + 2);
1924 pp_character (buffer, '{');
1925 newline_and_indent (buffer, spc + 4);
1926 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
1927 newline_and_indent (buffer, spc + 2);
1928 pp_character (buffer, '}');
1934 pp_string (buffer, "#pragma omp task");
1935 dump_omp_clauses (buffer, OMP_TASK_CLAUSES (node), spc, flags);
1939 pp_string (buffer, "#pragma omp for");
1940 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
1942 if (!(flags & TDF_SLIM))
1946 if (OMP_FOR_PRE_BODY (node))
1948 newline_and_indent (buffer, spc + 2);
1949 pp_character (buffer, '{');
1951 newline_and_indent (buffer, spc);
1952 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
1956 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
1959 newline_and_indent (buffer, spc);
1960 pp_string (buffer, "for (");
1961 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INIT (node), i),
1963 pp_string (buffer, "; ");
1964 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_COND (node), i),
1966 pp_string (buffer, "; ");
1967 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i),
1969 pp_string (buffer, ")");
1971 if (OMP_FOR_BODY (node))
1973 newline_and_indent (buffer, spc + 2);
1974 pp_character (buffer, '{');
1975 newline_and_indent (buffer, spc + 4);
1976 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
1978 newline_and_indent (buffer, spc + 2);
1979 pp_character (buffer, '}');
1981 spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
1982 if (OMP_FOR_PRE_BODY (node))
1985 newline_and_indent (buffer, spc + 2);
1986 pp_character (buffer, '}');
1993 pp_string (buffer, "#pragma omp sections");
1994 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
1998 pp_string (buffer, "#pragma omp section");
2002 pp_string (buffer, "#pragma omp master");
2006 pp_string (buffer, "#pragma omp ordered");
2010 pp_string (buffer, "#pragma omp critical");
2011 if (OMP_CRITICAL_NAME (node))
2014 pp_character (buffer, '(');
2015 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
2017 pp_character (buffer, ')');
2022 pp_string (buffer, "#pragma omp atomic");
2023 newline_and_indent (buffer, spc + 2);
2024 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2026 pp_character (buffer, '=');
2028 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2032 pp_string (buffer, "#pragma omp single");
2033 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
2037 dump_omp_clause (buffer, node, spc, flags);
2041 case REDUC_MAX_EXPR:
2042 pp_string (buffer, " REDUC_MAX_EXPR < ");
2043 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2044 pp_string (buffer, " > ");
2047 case REDUC_MIN_EXPR:
2048 pp_string (buffer, " REDUC_MIN_EXPR < ");
2049 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2050 pp_string (buffer, " > ");
2053 case REDUC_PLUS_EXPR:
2054 pp_string (buffer, " REDUC_PLUS_EXPR < ");
2055 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2056 pp_string (buffer, " > ");
2059 case VEC_WIDEN_MULT_HI_EXPR:
2060 pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
2061 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2062 pp_string (buffer, ", ");
2063 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2064 pp_string (buffer, " > ");
2067 case VEC_WIDEN_MULT_LO_EXPR:
2068 pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
2069 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2070 pp_string (buffer, ", ");
2071 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2072 pp_string (buffer, " > ");
2075 case VEC_UNPACK_HI_EXPR:
2076 pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
2077 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2078 pp_string (buffer, " > ");
2081 case VEC_UNPACK_LO_EXPR:
2082 pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
2083 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2084 pp_string (buffer, " > ");
2087 case VEC_UNPACK_FLOAT_HI_EXPR:
2088 pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2089 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2090 pp_string (buffer, " > ");
2093 case VEC_UNPACK_FLOAT_LO_EXPR:
2094 pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2095 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2096 pp_string (buffer, " > ");
2099 case VEC_PACK_TRUNC_EXPR:
2100 pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
2101 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2102 pp_string (buffer, ", ");
2103 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2104 pp_string (buffer, " > ");
2107 case VEC_PACK_SAT_EXPR:
2108 pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
2109 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2110 pp_string (buffer, ", ");
2111 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2112 pp_string (buffer, " > ");
2115 case VEC_PACK_FIX_TRUNC_EXPR:
2116 pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");
2117 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2118 pp_string (buffer, ", ");
2119 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2120 pp_string (buffer, " > ");
2124 dump_block_node (buffer, node, spc, flags);
2127 case VEC_EXTRACT_EVEN_EXPR:
2128 pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
2129 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2130 pp_string (buffer, ", ");
2131 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2132 pp_string (buffer, " > ");
2135 case VEC_EXTRACT_ODD_EXPR:
2136 pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
2137 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2138 pp_string (buffer, ", ");
2139 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2140 pp_string (buffer, " > ");
2143 case VEC_INTERLEAVE_HIGH_EXPR:
2144 pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
2145 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2146 pp_string (buffer, ", ");
2147 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2148 pp_string (buffer, " > ");
2151 case VEC_INTERLEAVE_LOW_EXPR:
2152 pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
2153 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2154 pp_string (buffer, ", ");
2155 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2156 pp_string (buffer, " > ");
2163 if (is_stmt && is_expr)
2164 pp_semicolon (buffer);
2166 /* If we're building a diagnostic, the formatted text will be written
2167 into BUFFER's stream by the caller; otherwise, write it now. */
2168 if (!(flags & TDF_DIAGNOSTIC))
2169 pp_write_text_to_stream (buffer);
2174 /* Print the declaration of a variable. */
2177 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2181 if (TREE_CODE (t) == TYPE_DECL)
2182 pp_string (buffer, "typedef ");
2184 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2185 pp_string (buffer, "register ");
2187 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2188 pp_string (buffer, "extern ");
2189 else if (TREE_STATIC (t))
2190 pp_string (buffer, "static ");
2192 /* Print the type and name. */
2193 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2197 /* Print array's type. */
2198 tmp = TREE_TYPE (t);
2199 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2200 tmp = TREE_TYPE (tmp);
2201 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2203 /* Print variable's name. */
2205 dump_generic_node (buffer, t, spc, flags, false);
2207 /* Print the dimensions. */
2208 tmp = TREE_TYPE (t);
2209 while (TREE_CODE (tmp) == ARRAY_TYPE)
2211 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
2212 tmp = TREE_TYPE (tmp);
2215 else if (TREE_CODE (t) == FUNCTION_DECL)
2217 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2219 dump_decl_name (buffer, t, flags);
2220 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2224 /* Print type declaration. */
2225 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2227 /* Print variable's name. */
2229 dump_generic_node (buffer, t, spc, flags, false);
2232 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2234 pp_string (buffer, " __asm__ ");
2235 pp_character (buffer, '(');
2236 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2237 pp_character (buffer, ')');
2240 /* The initial value of a function serves to determine whether the function
2241 is declared or defined. So the following does not apply to function
2243 if (TREE_CODE (t) != FUNCTION_DECL)
2245 /* Print the initial value. */
2246 if (DECL_INITIAL (t))
2249 pp_character (buffer, '=');
2251 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2255 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2257 pp_string (buffer, " [value-expr: ");
2258 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2259 pp_character (buffer, ']');
2262 pp_character (buffer, ';');
2266 /* Prints a structure: name, fields, and methods.
2267 FIXME: Still incomplete. */
2270 print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
2272 /* Print the name of the structure. */
2273 if (TYPE_NAME (node))
2276 if (TREE_CODE (node) == RECORD_TYPE)
2277 pp_string (buffer, "struct ");
2278 else if ((TREE_CODE (node) == UNION_TYPE
2279 || TREE_CODE (node) == QUAL_UNION_TYPE))
2280 pp_string (buffer, "union ");
2282 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2285 /* Print the contents of the structure. */
2286 pp_newline (buffer);
2288 pp_character (buffer, '{');
2289 pp_newline (buffer);
2291 /* Print the fields of the structure. */
2294 tmp = TYPE_FIELDS (node);
2297 /* Avoid to print recursively the structure. */
2298 /* FIXME : Not implemented correctly...,
2299 what about the case when we have a cycle in the contain graph? ...
2300 Maybe this could be solved by looking at the scope in which the
2301 structure was declared. */
2302 if (TREE_TYPE (tmp) != node
2303 && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
2304 || TREE_TYPE (TREE_TYPE (tmp)) != node))
2306 print_declaration (buffer, tmp, spc+2, flags);
2307 pp_newline (buffer);
2309 tmp = TREE_CHAIN (tmp);
2313 pp_character (buffer, '}');
2316 /* Return the priority of the operator CODE.
2318 From lowest to highest precedence with either left-to-right (L-R)
2319 or right-to-left (R-L) associativity]:
2322 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2334 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2335 15 [L-R] fn() [] -> .
2337 unary +, - and * have higher precedence than the corresponding binary
2341 op_code_prio (enum tree_code code)
2358 case TRUTH_ORIF_EXPR:
2361 case TRUTH_AND_EXPR:
2362 case TRUTH_ANDIF_EXPR:
2369 case TRUTH_XOR_EXPR:
2386 case UNORDERED_EXPR:
2399 case WIDEN_SUM_EXPR:
2401 case POINTER_PLUS_EXPR:
2405 case VEC_WIDEN_MULT_HI_EXPR:
2406 case VEC_WIDEN_MULT_LO_EXPR:
2407 case WIDEN_MULT_EXPR:
2410 case TRUNC_DIV_EXPR:
2412 case FLOOR_DIV_EXPR:
2413 case ROUND_DIV_EXPR:
2415 case EXACT_DIV_EXPR:
2416 case TRUNC_MOD_EXPR:
2418 case FLOOR_MOD_EXPR:
2419 case ROUND_MOD_EXPR:
2422 case TRUTH_NOT_EXPR:
2424 case POSTINCREMENT_EXPR:
2425 case POSTDECREMENT_EXPR:
2426 case PREINCREMENT_EXPR:
2427 case PREDECREMENT_EXPR:
2429 case ALIGN_INDIRECT_REF:
2430 case MISALIGNED_INDIRECT_REF:
2435 case FIX_TRUNC_EXPR:
2441 case ARRAY_RANGE_REF:
2445 /* Special expressions. */
2451 case REDUC_MAX_EXPR:
2452 case REDUC_MIN_EXPR:
2453 case REDUC_PLUS_EXPR:
2454 case VEC_LSHIFT_EXPR:
2455 case VEC_RSHIFT_EXPR:
2456 case VEC_UNPACK_HI_EXPR:
2457 case VEC_UNPACK_LO_EXPR:
2458 case VEC_UNPACK_FLOAT_HI_EXPR:
2459 case VEC_UNPACK_FLOAT_LO_EXPR:
2460 case VEC_PACK_TRUNC_EXPR:
2461 case VEC_PACK_SAT_EXPR:
2465 /* Return an arbitrarily high precedence to avoid surrounding single
2466 VAR_DECLs in ()s. */
2471 /* Return the priority of the operator OP. */
2474 op_prio (const_tree op)
2476 enum tree_code code;
2481 code = TREE_CODE (op);
2482 if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
2483 return op_prio (TREE_OPERAND (op, 0));
2485 return op_code_prio (code);
2488 /* Return the symbol associated with operator CODE. */
2491 op_symbol_code (enum tree_code code)
2499 case TRUTH_ORIF_EXPR:
2502 case TRUTH_AND_EXPR:
2503 case TRUTH_ANDIF_EXPR:
2509 case TRUTH_XOR_EXPR:
2519 case UNORDERED_EXPR:
2565 case VEC_LSHIFT_EXPR:
2568 case VEC_RSHIFT_EXPR:
2571 case POINTER_PLUS_EXPR:
2577 case REDUC_PLUS_EXPR:
2580 case WIDEN_SUM_EXPR:
2583 case WIDEN_MULT_EXPR:
2593 case TRUTH_NOT_EXPR:
2600 case ALIGN_INDIRECT_REF:
2603 case MISALIGNED_INDIRECT_REF:
2606 case TRUNC_DIV_EXPR:
2613 case FLOOR_DIV_EXPR:
2616 case ROUND_DIV_EXPR:
2619 case EXACT_DIV_EXPR:
2622 case TRUNC_MOD_EXPR:
2628 case FLOOR_MOD_EXPR:
2631 case ROUND_MOD_EXPR:
2634 case PREDECREMENT_EXPR:
2637 case PREINCREMENT_EXPR:
2640 case POSTDECREMENT_EXPR:
2643 case POSTINCREMENT_EXPR:
2653 return "<<< ??? >>>";
2657 /* Return the symbol associated with operator OP. */
2660 op_symbol (const_tree op)
2662 return op_symbol_code (TREE_CODE (op));
2665 /* Prints the name of a CALL_EXPR. */
2668 print_call_name (pretty_printer *buffer, const_tree node)
2672 gcc_assert (TREE_CODE (node) == CALL_EXPR);
2674 op0 = CALL_EXPR_FN (node);
2676 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2677 op0 = TREE_OPERAND (op0, 0);
2679 switch (TREE_CODE (op0))
2683 dump_function_name (buffer, op0);
2689 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2693 pp_string (buffer, "(");
2694 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2695 pp_string (buffer, ") ? ");
2696 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
2697 pp_string (buffer, " : ");
2698 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
2702 /* The function is a pointer contained in a structure. */
2703 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
2704 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2705 dump_function_name (buffer, TREE_OPERAND (op0, 1));
2707 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2709 We can have several levels of structures and a function
2710 pointer inside. This is not implemented yet... */
2715 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2716 dump_function_name (buffer, TREE_OPERAND (op0, 0));
2718 dump_generic_node (buffer, op0, 0, 0, false);
2723 dump_generic_node (buffer, op0, 0, 0, false);
2731 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2734 pretty_print_string (pretty_printer *buffer, const char *str)
2744 pp_string (buffer, "\\b");
2748 pp_string (buffer, "\\f");
2752 pp_string (buffer, "\\n");
2756 pp_string (buffer, "\\r");
2760 pp_string (buffer, "\\t");
2764 pp_string (buffer, "\\v");
2768 pp_string (buffer, "\\\\");
2772 pp_string (buffer, "\\\"");
2776 pp_string (buffer, "\\'");
2779 /* No need to handle \0; the loop terminates on \0. */
2782 pp_string (buffer, "\\1");
2786 pp_string (buffer, "\\2");
2790 pp_string (buffer, "\\3");
2794 pp_string (buffer, "\\4");
2798 pp_string (buffer, "\\5");
2802 pp_string (buffer, "\\6");
2806 pp_string (buffer, "\\7");
2810 pp_character (buffer, str[0]);
2818 maybe_init_pretty_print (FILE *file)
2822 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2823 pp_needs_newline (&buffer) = true;
2824 pp_translate_identifiers (&buffer) = false;
2828 buffer.buffer->stream = file;
2832 newline_and_indent (pretty_printer *buffer, int spc)
2834 pp_newline (buffer);