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 newline_and_indent (pretty_printer
*, int);
44 static void maybe_init_pretty_print (FILE *);
45 static void print_struct_decl (pretty_printer
*, const_tree
, int, int);
46 static void do_niy (pretty_printer
*, const_tree
);
48 #define INDENT(SPACE) do { \
49 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
51 #define NIY do_niy(buffer,node)
53 static pretty_printer buffer
;
54 static int initialized
= 0;
56 /* Try to print something for an unknown tree code. */
59 do_niy (pretty_printer
*buffer
, const_tree node
)
63 pp_string (buffer
, "<<< Unknown tree: ");
64 pp_string (buffer
, tree_code_name
[(int) TREE_CODE (node
)]);
68 len
= TREE_OPERAND_LENGTH (node
);
69 for (i
= 0; i
< len
; ++i
)
71 newline_and_indent (buffer
, 2);
72 dump_generic_node (buffer
, TREE_OPERAND (node
, i
), 2, 0, false);
76 pp_string (buffer
, " >>>\n");
79 /* Debugging function to print out a generic expression. */
82 debug_generic_expr (tree t
)
84 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
85 fprintf (stderr
, "\n");
88 /* Debugging function to print out a generic statement. */
91 debug_generic_stmt (tree t
)
93 print_generic_stmt (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
);
94 fprintf (stderr
, "\n");
97 /* Debugging function to print out a chain of trees . */
100 debug_tree_chain (tree t
)
102 struct pointer_set_t
*seen
= pointer_set_create ();
106 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
107 fprintf (stderr
, " ");
109 if (pointer_set_insert (seen
, t
))
111 fprintf (stderr
, "... [cycled back to ");
112 print_generic_expr (stderr
, t
, TDF_VOPS
|TDF_MEMSYMS
|TDF_UID
);
113 fprintf (stderr
, "]");
117 fprintf (stderr
, "\n");
119 pointer_set_destroy (seen
);
122 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
124 print_generic_decl (FILE *file
, tree decl
, int flags
)
126 maybe_init_pretty_print (file
);
127 print_declaration (&buffer
, decl
, 2, flags
);
128 pp_write_text_to_stream (&buffer
);
131 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
132 to show in the dump. See TDF_* in tree-pass.h. */
135 print_generic_stmt (FILE *file
, tree t
, int flags
)
137 maybe_init_pretty_print (file
);
138 dump_generic_node (&buffer
, t
, 0, flags
, true);
142 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
143 to show in the dump. See TDF_* in tree-pass.h. The output is indented by
147 print_generic_stmt_indented (FILE *file
, tree t
, int flags
, int indent
)
151 maybe_init_pretty_print (file
);
153 for (i
= 0; i
< indent
; i
++)
155 dump_generic_node (&buffer
, t
, indent
, flags
, true);
159 /* Print a single expression T on file FILE. FLAGS specifies details to show
160 in the dump. See TDF_* in tree-pass.h. */
163 print_generic_expr (FILE *file
, tree t
, int flags
)
165 maybe_init_pretty_print (file
);
166 dump_generic_node (&buffer
, t
, 0, flags
, false);
169 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
173 dump_decl_name (pretty_printer
*buffer
, tree node
, int flags
)
175 if (DECL_NAME (node
))
177 if ((flags
& TDF_ASMNAME
) && DECL_ASSEMBLER_NAME_SET_P (node
))
178 pp_tree_identifier (buffer
, DECL_ASSEMBLER_NAME (node
));
180 pp_tree_identifier (buffer
, DECL_NAME (node
));
182 if ((flags
& TDF_UID
) || DECL_NAME (node
) == NULL_TREE
)
184 if (TREE_CODE (node
) == LABEL_DECL
&& LABEL_DECL_UID (node
) != -1)
185 pp_printf (buffer
, "L.%d", (int) LABEL_DECL_UID (node
));
186 else if (TREE_CODE (node
) == DEBUG_EXPR_DECL
)
188 if (flags
& TDF_NOUID
)
189 pp_string (buffer
, "D#xxxx");
191 pp_printf (buffer
, "D#%i", DEBUG_TEMP_UID (node
));
195 char c
= TREE_CODE (node
) == CONST_DECL
? 'C' : 'D';
196 if (flags
& TDF_NOUID
)
197 pp_printf (buffer
, "%c.xxxx", c
);
199 pp_printf (buffer
, "%c.%u", c
, DECL_UID (node
));
204 /* Like the above, but used for pretty printing function calls. */
207 dump_function_name (pretty_printer
*buffer
, tree node
, int flags
)
209 if (TREE_CODE (node
) == NOP_EXPR
)
210 node
= TREE_OPERAND (node
, 0);
211 if (DECL_NAME (node
) && (flags
& TDF_ASMNAME
) == 0)
212 pp_string (buffer
, lang_hooks
.decl_printable_name (node
, 1));
214 dump_decl_name (buffer
, node
, flags
);
217 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
218 FLAGS are as in dump_generic_node. */
221 dump_function_declaration (pretty_printer
*buffer
, tree node
,
224 bool wrote_arg
= false;
228 pp_character (buffer
, '(');
230 /* Print the argument types. The last element in the list is a VOID_TYPE.
231 The following avoids printing the last element. */
232 arg
= TYPE_ARG_TYPES (node
);
233 while (arg
&& TREE_CHAIN (arg
) && arg
!= error_mark_node
)
236 dump_generic_node (buffer
, TREE_VALUE (arg
), spc
, flags
, false);
237 arg
= TREE_CHAIN (arg
);
238 if (TREE_CHAIN (arg
) && TREE_CODE (TREE_CHAIN (arg
)) == TREE_LIST
)
240 pp_character (buffer
, ',');
246 pp_string (buffer
, "void");
248 pp_character (buffer
, ')');
251 /* Dump the domain associated with an array. */
254 dump_array_domain (pretty_printer
*buffer
, tree domain
, int spc
, int flags
)
256 pp_character (buffer
, '[');
259 tree min
= TYPE_MIN_VALUE (domain
);
260 tree max
= TYPE_MAX_VALUE (domain
);
263 && integer_zerop (min
)
264 && host_integerp (max
, 0))
265 pp_wide_integer (buffer
, TREE_INT_CST_LOW (max
) + 1);
269 dump_generic_node (buffer
, min
, spc
, flags
, false);
270 pp_character (buffer
, ':');
272 dump_generic_node (buffer
, max
, spc
, flags
, false);
276 pp_string (buffer
, "<unknown>");
277 pp_character (buffer
, ']');
281 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
282 dump_generic_node. */
285 dump_omp_clause (pretty_printer
*buffer
, tree clause
, int spc
, int flags
)
289 switch (OMP_CLAUSE_CODE (clause
))
291 case OMP_CLAUSE_PRIVATE
:
294 case OMP_CLAUSE_SHARED
:
297 case OMP_CLAUSE_FIRSTPRIVATE
:
298 name
= "firstprivate";
300 case OMP_CLAUSE_LASTPRIVATE
:
301 name
= "lastprivate";
303 case OMP_CLAUSE_COPYIN
:
306 case OMP_CLAUSE_COPYPRIVATE
:
307 name
= "copyprivate";
310 pp_string (buffer
, name
);
311 pp_character (buffer
, '(');
312 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
314 pp_character (buffer
, ')');
317 case OMP_CLAUSE_REDUCTION
:
318 pp_string (buffer
, "reduction(");
319 pp_string (buffer
, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause
)));
320 pp_character (buffer
, ':');
321 dump_generic_node (buffer
, OMP_CLAUSE_DECL (clause
),
323 pp_character (buffer
, ')');
327 pp_string (buffer
, "if(");
328 dump_generic_node (buffer
, OMP_CLAUSE_IF_EXPR (clause
),
330 pp_character (buffer
, ')');
333 case OMP_CLAUSE_NUM_THREADS
:
334 pp_string (buffer
, "num_threads(");
335 dump_generic_node (buffer
, OMP_CLAUSE_NUM_THREADS_EXPR (clause
),
337 pp_character (buffer
, ')');
340 case OMP_CLAUSE_NOWAIT
:
341 pp_string (buffer
, "nowait");
343 case OMP_CLAUSE_ORDERED
:
344 pp_string (buffer
, "ordered");
347 case OMP_CLAUSE_DEFAULT
:
348 pp_string (buffer
, "default(");
349 switch (OMP_CLAUSE_DEFAULT_KIND (clause
))
351 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
353 case OMP_CLAUSE_DEFAULT_SHARED
:
354 pp_string (buffer
, "shared");
356 case OMP_CLAUSE_DEFAULT_NONE
:
357 pp_string (buffer
, "none");
359 case OMP_CLAUSE_DEFAULT_PRIVATE
:
360 pp_string (buffer
, "private");
362 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
363 pp_string (buffer
, "firstprivate");
368 pp_character (buffer
, ')');
371 case OMP_CLAUSE_SCHEDULE
:
372 pp_string (buffer
, "schedule(");
373 switch (OMP_CLAUSE_SCHEDULE_KIND (clause
))
375 case OMP_CLAUSE_SCHEDULE_STATIC
:
376 pp_string (buffer
, "static");
378 case OMP_CLAUSE_SCHEDULE_DYNAMIC
:
379 pp_string (buffer
, "dynamic");
381 case OMP_CLAUSE_SCHEDULE_GUIDED
:
382 pp_string (buffer
, "guided");
384 case OMP_CLAUSE_SCHEDULE_RUNTIME
:
385 pp_string (buffer
, "runtime");
387 case OMP_CLAUSE_SCHEDULE_AUTO
:
388 pp_string (buffer
, "auto");
393 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
))
395 pp_character (buffer
, ',');
396 dump_generic_node (buffer
,
397 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
),
400 pp_character (buffer
, ')');
403 case OMP_CLAUSE_UNTIED
:
404 pp_string (buffer
, "untied");
407 case OMP_CLAUSE_COLLAPSE
:
408 pp_string (buffer
, "collapse(");
409 dump_generic_node (buffer
,
410 OMP_CLAUSE_COLLAPSE_EXPR (clause
),
412 pp_character (buffer
, ')');
416 /* Should never happen. */
417 dump_generic_node (buffer
, clause
, spc
, flags
, false);
423 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
424 dump_generic_node. */
427 dump_omp_clauses (pretty_printer
*buffer
, tree clause
, int spc
, int flags
)
435 dump_omp_clause (buffer
, clause
, spc
, flags
);
436 clause
= OMP_CLAUSE_CHAIN (clause
);
444 /* Dump location LOC to BUFFER. */
447 dump_location (pretty_printer
*buffer
, location_t loc
)
449 expanded_location xloc
= expand_location (loc
);
451 pp_character (buffer
, '[');
454 pp_string (buffer
, xloc
.file
);
455 pp_string (buffer
, " : ");
457 pp_decimal_int (buffer
, xloc
.line
);
458 pp_string (buffer
, "] ");
462 /* Dump lexical block BLOCK. BUFFER, SPC and FLAGS are as in
463 dump_generic_node. */
466 dump_block_node (pretty_printer
*buffer
, tree block
, int spc
, int flags
)
470 pp_printf (buffer
, "BLOCK #%d ", BLOCK_NUMBER (block
));
472 if (flags
& TDF_ADDRESS
)
473 pp_printf (buffer
, "[%p] ", (void *) block
);
475 if (BLOCK_ABSTRACT (block
))
476 pp_string (buffer
, "[abstract] ");
478 if (TREE_ASM_WRITTEN (block
))
479 pp_string (buffer
, "[written] ");
481 if (flags
& TDF_SLIM
)
484 if (BLOCK_SOURCE_LOCATION (block
))
485 dump_location (buffer
, BLOCK_SOURCE_LOCATION (block
));
487 newline_and_indent (buffer
, spc
+ 2);
489 if (BLOCK_SUPERCONTEXT (block
))
491 pp_string (buffer
, "SUPERCONTEXT: ");
492 dump_generic_node (buffer
, BLOCK_SUPERCONTEXT (block
), 0,
493 flags
| TDF_SLIM
, false);
494 newline_and_indent (buffer
, spc
+ 2);
497 if (BLOCK_SUBBLOCKS (block
))
499 pp_string (buffer
, "SUBBLOCKS: ");
500 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
502 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
503 pp_string (buffer
, " ");
505 newline_and_indent (buffer
, spc
+ 2);
508 if (BLOCK_CHAIN (block
))
510 pp_string (buffer
, "SIBLINGS: ");
511 for (t
= BLOCK_CHAIN (block
); t
; t
= BLOCK_CHAIN (t
))
513 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
514 pp_string (buffer
, " ");
516 newline_and_indent (buffer
, spc
+ 2);
519 if (BLOCK_VARS (block
))
521 pp_string (buffer
, "VARS: ");
522 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
524 dump_generic_node (buffer
, t
, 0, flags
, false);
525 pp_string (buffer
, " ");
527 newline_and_indent (buffer
, spc
+ 2);
530 if (VEC_length (tree
, BLOCK_NONLOCALIZED_VARS (block
)) > 0)
533 VEC(tree
,gc
) *nlv
= BLOCK_NONLOCALIZED_VARS (block
);
535 pp_string (buffer
, "NONLOCALIZED_VARS: ");
536 for (i
= 0; VEC_iterate (tree
, nlv
, i
, t
); i
++)
538 dump_generic_node (buffer
, t
, 0, flags
, false);
539 pp_string (buffer
, " ");
541 newline_and_indent (buffer
, spc
+ 2);
544 if (BLOCK_ABSTRACT_ORIGIN (block
))
546 pp_string (buffer
, "ABSTRACT_ORIGIN: ");
547 dump_generic_node (buffer
, BLOCK_ABSTRACT_ORIGIN (block
), 0,
548 flags
| TDF_SLIM
, false);
549 newline_and_indent (buffer
, spc
+ 2);
552 if (BLOCK_FRAGMENT_ORIGIN (block
))
554 pp_string (buffer
, "FRAGMENT_ORIGIN: ");
555 dump_generic_node (buffer
, BLOCK_FRAGMENT_ORIGIN (block
), 0,
556 flags
| TDF_SLIM
, false);
557 newline_and_indent (buffer
, spc
+ 2);
560 if (BLOCK_FRAGMENT_CHAIN (block
))
562 pp_string (buffer
, "FRAGMENT_CHAIN: ");
563 for (t
= BLOCK_FRAGMENT_CHAIN (block
); t
; t
= BLOCK_FRAGMENT_CHAIN (t
))
565 dump_generic_node (buffer
, t
, 0, flags
| TDF_SLIM
, false);
566 pp_string (buffer
, " ");
568 newline_and_indent (buffer
, spc
+ 2);
573 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
574 indent. FLAGS specifies details to show in the dump (see TDF_* in
575 tree-pass.h). If IS_STMT is true, the object printed is considered
576 to be a statement and it is terminated by ';' if appropriate. */
579 dump_generic_node (pretty_printer
*buffer
, tree node
, int spc
, int flags
,
587 if (node
== NULL_TREE
)
590 is_expr
= EXPR_P (node
);
592 if (is_stmt
&& (flags
& TDF_STMTADDR
))
593 pp_printf (buffer
, "<&%p> ", (void *)node
);
595 if ((flags
& TDF_LINENO
) && EXPR_HAS_LOCATION (node
))
596 dump_location (buffer
, EXPR_LOCATION (node
));
598 switch (TREE_CODE (node
))
601 pp_string (buffer
, "<<< error >>>");
604 case IDENTIFIER_NODE
:
605 pp_tree_identifier (buffer
, node
);
609 while (node
&& node
!= error_mark_node
)
611 if (TREE_PURPOSE (node
))
613 dump_generic_node (buffer
, TREE_PURPOSE (node
), spc
, flags
, false);
616 dump_generic_node (buffer
, TREE_VALUE (node
), spc
, flags
, false);
617 node
= TREE_CHAIN (node
);
618 if (node
&& TREE_CODE (node
) == TREE_LIST
)
620 pp_character (buffer
, ',');
627 dump_generic_node (buffer
, BINFO_TYPE (node
), spc
, flags
, false);
633 if (TREE_VEC_LENGTH (node
) > 0)
635 size_t len
= TREE_VEC_LENGTH (node
);
636 for (i
= 0; i
< len
- 1; i
++)
638 dump_generic_node (buffer
, TREE_VEC_ELT (node
, i
), spc
, flags
,
640 pp_character (buffer
, ',');
643 dump_generic_node (buffer
, TREE_VEC_ELT (node
, len
- 1), spc
,
652 case FIXED_POINT_TYPE
:
658 unsigned int quals
= TYPE_QUALS (node
);
659 enum tree_code_class tclass
;
661 if (quals
& TYPE_QUAL_CONST
)
662 pp_string (buffer
, "const ");
663 else if (quals
& TYPE_QUAL_VOLATILE
)
664 pp_string (buffer
, "volatile ");
665 else if (quals
& TYPE_QUAL_RESTRICT
)
666 pp_string (buffer
, "restrict ");
668 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
670 pp_string (buffer
, "<address-space-");
671 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
672 pp_string (buffer
, "> ");
675 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
677 if (tclass
== tcc_declaration
)
679 if (DECL_NAME (node
))
680 dump_decl_name (buffer
, node
, flags
);
682 pp_string (buffer
, "<unnamed type decl>");
684 else if (tclass
== tcc_type
)
686 if (TYPE_NAME (node
))
688 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
689 pp_tree_identifier (buffer
, TYPE_NAME (node
));
690 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
691 && DECL_NAME (TYPE_NAME (node
)))
692 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
694 pp_string (buffer
, "<unnamed type>");
696 else if (TREE_CODE (node
) == VECTOR_TYPE
)
698 pp_string (buffer
, "vector ");
699 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
701 else if (TREE_CODE (node
) == INTEGER_TYPE
)
703 pp_string (buffer
, (TYPE_UNSIGNED (node
)
704 ? "<unnamed-unsigned:"
705 : "<unnamed-signed:"));
706 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
707 pp_string (buffer
, ">");
709 else if (TREE_CODE (node
) == COMPLEX_TYPE
)
711 pp_string (buffer
, "__complex__ ");
712 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
714 else if (TREE_CODE (node
) == REAL_TYPE
)
716 pp_string (buffer
, "<float:");
717 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
718 pp_string (buffer
, ">");
720 else if (TREE_CODE (node
) == FIXED_POINT_TYPE
)
722 pp_string (buffer
, "<fixed-point-");
723 pp_string (buffer
, TYPE_SATURATING (node
) ? "sat:" : "nonsat:");
724 pp_decimal_int (buffer
, TYPE_PRECISION (node
));
725 pp_string (buffer
, ">");
728 pp_string (buffer
, "<unnamed type>");
735 str
= (TREE_CODE (node
) == POINTER_TYPE
? "*" : "&");
737 if (TREE_TYPE (node
) == NULL
)
739 pp_string (buffer
, str
);
740 pp_string (buffer
, "<null type>");
742 else if (TREE_CODE (TREE_TYPE (node
)) == FUNCTION_TYPE
)
744 tree fnode
= TREE_TYPE (node
);
746 dump_generic_node (buffer
, TREE_TYPE (fnode
), spc
, flags
, false);
748 pp_character (buffer
, '(');
749 pp_string (buffer
, str
);
750 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
751 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
753 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
755 pp_character (buffer
, ')');
756 dump_function_declaration (buffer
, fnode
, spc
, flags
);
760 unsigned int quals
= TYPE_QUALS (node
);
762 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
764 pp_string (buffer
, str
);
766 if (quals
& TYPE_QUAL_CONST
)
767 pp_string (buffer
, " const");
768 if (quals
& TYPE_QUAL_VOLATILE
)
769 pp_string (buffer
, " volatile");
770 if (quals
& TYPE_QUAL_RESTRICT
)
771 pp_string (buffer
, " restrict");
773 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node
)))
775 pp_string (buffer
, " <address-space-");
776 pp_decimal_int (buffer
, TYPE_ADDR_SPACE (node
));
777 pp_string (buffer
, ">");
780 if (TYPE_REF_CAN_ALIAS_ALL (node
))
781 pp_string (buffer
, " {ref-all}");
791 const char *sep
= "";
794 pp_string (buffer
, "MEM[");
796 tmp
= TMR_SYMBOL (node
);
799 pp_string (buffer
, sep
);
801 pp_string (buffer
, "symbol: ");
802 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
804 tmp
= TMR_BASE (node
);
807 pp_string (buffer
, sep
);
809 pp_string (buffer
, "base: ");
810 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
812 tmp
= TMR_INDEX (node
);
815 pp_string (buffer
, sep
);
817 pp_string (buffer
, "index: ");
818 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
820 tmp
= TMR_STEP (node
);
823 pp_string (buffer
, sep
);
825 pp_string (buffer
, "step: ");
826 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
828 tmp
= TMR_OFFSET (node
);
831 pp_string (buffer
, sep
);
833 pp_string (buffer
, "offset: ");
834 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
836 pp_string (buffer
, "]");
837 if (flags
& TDF_DETAILS
)
839 pp_string (buffer
, "{");
840 dump_generic_node (buffer
, TMR_ORIGINAL (node
), spc
, flags
,
842 pp_string (buffer
, "}");
851 /* Print the innermost component type. */
852 for (tmp
= TREE_TYPE (node
); TREE_CODE (tmp
) == ARRAY_TYPE
;
853 tmp
= TREE_TYPE (tmp
))
855 dump_generic_node (buffer
, tmp
, spc
, flags
, false);
857 /* Print the dimensions. */
858 for (tmp
= node
; TREE_CODE (tmp
) == ARRAY_TYPE
; tmp
= TREE_TYPE (tmp
))
859 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
865 case QUAL_UNION_TYPE
:
867 unsigned int quals
= TYPE_QUALS (node
);
869 if (quals
& TYPE_QUAL_CONST
)
870 pp_string (buffer
, "const ");
871 if (quals
& TYPE_QUAL_VOLATILE
)
872 pp_string (buffer
, "volatile ");
874 /* Print the name of the structure. */
875 if (TREE_CODE (node
) == RECORD_TYPE
)
876 pp_string (buffer
, "struct ");
877 else if (TREE_CODE (node
) == UNION_TYPE
)
878 pp_string (buffer
, "union ");
880 if (TYPE_NAME (node
))
881 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, flags
, false);
882 else if (!(flags
& TDF_SLIM
))
883 /* FIXME: If we eliminate the 'else' above and attempt
884 to show the fields for named types, we may get stuck
885 following a cycle of pointers to structs. The alleged
886 self-reference check in print_struct_decl will not detect
887 cycles involving more than one pointer or struct type. */
888 print_struct_decl (buffer
, node
, spc
, flags
);
897 if (TREE_CODE (TREE_TYPE (node
)) == POINTER_TYPE
)
899 /* In the case of a pointer, one may want to divide by the
900 size of the pointed-to type. Unfortunately, this not
901 straightforward. The C front-end maps expressions
906 in such a way that the two INTEGER_CST nodes for "5" have
907 different values but identical types. In the latter
908 case, the 5 is multiplied by sizeof (int) in c-common.c
909 (pointer_int_sum) to convert it to a byte address, and
910 yet the type of the node is left unchanged. Argh. What
911 is consistent though is that the number value corresponds
912 to bytes (UNITS) offset.
914 NB: Neither of the following divisors can be trivially
915 used to recover the original literal:
917 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
918 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
919 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
920 pp_string (buffer
, "B"); /* pseudo-unit */
922 else if (! host_integerp (node
, 0))
925 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (val
);
926 HOST_WIDE_INT high
= TREE_INT_CST_HIGH (val
);
928 if (tree_int_cst_sgn (val
) < 0)
930 pp_character (buffer
, '-');
934 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
936 sprintf (pp_buffer (buffer
)->digit_buffer
,
937 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
938 (unsigned HOST_WIDE_INT
) high
, low
);
939 pp_string (buffer
, pp_buffer (buffer
)->digit_buffer
);
942 pp_wide_integer (buffer
, TREE_INT_CST_LOW (node
));
946 /* Code copied from print_node. */
949 if (TREE_OVERFLOW (node
))
950 pp_string (buffer
, " overflow");
952 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
953 d
= TREE_REAL_CST (node
);
954 if (REAL_VALUE_ISINF (d
))
955 pp_string (buffer
, REAL_VALUE_NEGATIVE (d
) ? " -Inf" : " Inf");
956 else if (REAL_VALUE_ISNAN (d
))
957 pp_string (buffer
, " Nan");
961 real_to_decimal (string
, &d
, sizeof (string
), 0, 1);
962 pp_string (buffer
, string
);
967 unsigned char *p
= (unsigned char *) &TREE_REAL_CST (node
);
968 pp_string (buffer
, "0x");
969 for (i
= 0; i
< sizeof TREE_REAL_CST (node
); i
++)
970 output_formatted_integer (buffer
, "%02x", *p
++);
979 fixed_to_decimal (string
, TREE_FIXED_CST_PTR (node
), sizeof (string
));
980 pp_string (buffer
, string
);
985 pp_string (buffer
, "__complex__ (");
986 dump_generic_node (buffer
, TREE_REALPART (node
), spc
, flags
, false);
987 pp_string (buffer
, ", ");
988 dump_generic_node (buffer
, TREE_IMAGPART (node
), spc
, flags
, false);
989 pp_string (buffer
, ")");
993 pp_string (buffer
, "\"");
994 pretty_print_string (buffer
, TREE_STRING_POINTER (node
));
995 pp_string (buffer
, "\"");
1001 pp_string (buffer
, "{ ");
1002 for (elt
= TREE_VECTOR_CST_ELTS (node
); elt
; elt
= TREE_CHAIN (elt
))
1004 dump_generic_node (buffer
, TREE_VALUE (elt
), spc
, flags
, false);
1005 if (TREE_CHAIN (elt
))
1006 pp_string (buffer
, ", ");
1008 pp_string (buffer
, " }");
1014 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1016 if (TREE_CODE (node
) == METHOD_TYPE
)
1018 if (TYPE_METHOD_BASETYPE (node
))
1019 dump_decl_name (buffer
, TYPE_NAME (TYPE_METHOD_BASETYPE (node
)),
1022 pp_string (buffer
, "<null method basetype>");
1023 pp_string (buffer
, "::");
1025 if (TYPE_NAME (node
) && DECL_NAME (TYPE_NAME (node
)))
1026 dump_decl_name (buffer
, TYPE_NAME (node
), flags
);
1028 pp_printf (buffer
, "<T%x>", TYPE_UID (node
));
1029 dump_function_declaration (buffer
, node
, spc
, flags
);
1034 dump_decl_name (buffer
, node
, flags
);
1038 if (DECL_NAME (node
))
1039 dump_decl_name (buffer
, node
, flags
);
1040 else if (LABEL_DECL_UID (node
) != -1)
1041 pp_printf (buffer
, "<L%d>", (int) LABEL_DECL_UID (node
));
1044 if (flags
& TDF_NOUID
)
1045 pp_string (buffer
, "<D.xxxx>");
1047 pp_printf (buffer
, "<D.%u>", DECL_UID (node
));
1052 if (DECL_IS_BUILTIN (node
))
1054 /* Don't print the declaration of built-in types. */
1057 if (DECL_NAME (node
))
1058 dump_decl_name (buffer
, node
, flags
);
1061 if ((TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1062 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1063 && TYPE_METHODS (TREE_TYPE (node
)))
1065 /* The type is a c++ class: all structures have at least
1067 pp_string (buffer
, "class ");
1068 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1073 (TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
1074 ? "union" : "struct "));
1075 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1083 case DEBUG_EXPR_DECL
:
1084 case NAMESPACE_DECL
:
1085 dump_decl_name (buffer
, node
, flags
);
1089 pp_string (buffer
, "<retval>");
1093 op0
= TREE_OPERAND (node
, 0);
1095 if (op0
&& TREE_CODE (op0
) == INDIRECT_REF
)
1097 op0
= TREE_OPERAND (op0
, 0);
1100 if (op_prio (op0
) < op_prio (node
))
1101 pp_character (buffer
, '(');
1102 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1103 if (op_prio (op0
) < op_prio (node
))
1104 pp_character (buffer
, ')');
1105 pp_string (buffer
, str
);
1106 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1107 op0
= component_ref_field_offset (node
);
1108 if (op0
&& TREE_CODE (op0
) != INTEGER_CST
)
1110 pp_string (buffer
, "{off: ");
1111 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1112 pp_character (buffer
, '}');
1117 pp_string (buffer
, "BIT_FIELD_REF <");
1118 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1119 pp_string (buffer
, ", ");
1120 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1121 pp_string (buffer
, ", ");
1122 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1123 pp_string (buffer
, ">");
1127 case ARRAY_RANGE_REF
:
1128 op0
= TREE_OPERAND (node
, 0);
1129 if (op_prio (op0
) < op_prio (node
))
1130 pp_character (buffer
, '(');
1131 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1132 if (op_prio (op0
) < op_prio (node
))
1133 pp_character (buffer
, ')');
1134 pp_character (buffer
, '[');
1135 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1136 if (TREE_CODE (node
) == ARRAY_RANGE_REF
)
1137 pp_string (buffer
, " ...");
1138 pp_character (buffer
, ']');
1140 op0
= array_ref_low_bound (node
);
1141 op1
= array_ref_element_size (node
);
1143 if (!integer_zerop (op0
)
1144 || TREE_OPERAND (node
, 2)
1145 || TREE_OPERAND (node
, 3))
1147 pp_string (buffer
, "{lb: ");
1148 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1149 pp_string (buffer
, " sz: ");
1150 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1151 pp_character (buffer
, '}');
1157 unsigned HOST_WIDE_INT ix
;
1159 bool is_struct_init
= FALSE
;
1160 pp_character (buffer
, '{');
1161 if (TREE_CODE (TREE_TYPE (node
)) == RECORD_TYPE
1162 || TREE_CODE (TREE_TYPE (node
)) == UNION_TYPE
)
1163 is_struct_init
= TRUE
;
1164 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
), ix
, field
, val
)
1166 if (field
&& is_struct_init
)
1168 pp_character (buffer
, '.');
1169 dump_generic_node (buffer
, field
, spc
, flags
, false);
1170 pp_string (buffer
, "=");
1172 if (val
&& TREE_CODE (val
) == ADDR_EXPR
)
1173 if (TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
)
1174 val
= TREE_OPERAND (val
, 0);
1175 if (val
&& TREE_CODE (val
) == FUNCTION_DECL
)
1176 dump_decl_name (buffer
, val
, flags
);
1178 dump_generic_node (buffer
, val
, spc
, flags
, false);
1179 if (ix
!= VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (node
)) - 1)
1181 pp_character (buffer
, ',');
1185 pp_character (buffer
, '}');
1192 if (flags
& TDF_SLIM
)
1194 pp_string (buffer
, "<COMPOUND_EXPR>");
1198 dump_generic_node (buffer
, TREE_OPERAND (node
, 0),
1199 spc
, flags
, !(flags
& TDF_SLIM
));
1200 if (flags
& TDF_SLIM
)
1201 newline_and_indent (buffer
, spc
);
1204 pp_character (buffer
, ',');
1208 for (tp
= &TREE_OPERAND (node
, 1);
1209 TREE_CODE (*tp
) == COMPOUND_EXPR
;
1210 tp
= &TREE_OPERAND (*tp
, 1))
1212 dump_generic_node (buffer
, TREE_OPERAND (*tp
, 0),
1213 spc
, flags
, !(flags
& TDF_SLIM
));
1214 if (flags
& TDF_SLIM
)
1215 newline_and_indent (buffer
, spc
);
1218 pp_character (buffer
, ',');
1223 dump_generic_node (buffer
, *tp
, spc
, flags
, !(flags
& TDF_SLIM
));
1227 case STATEMENT_LIST
:
1229 tree_stmt_iterator si
;
1232 if (flags
& TDF_SLIM
)
1234 pp_string (buffer
, "<STATEMENT_LIST>");
1238 for (si
= tsi_start (node
); !tsi_end_p (si
); tsi_next (&si
))
1241 newline_and_indent (buffer
, spc
);
1244 dump_generic_node (buffer
, tsi_stmt (si
), spc
, flags
, true);
1251 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
,
1254 pp_character (buffer
, '=');
1255 if (TREE_CODE (node
) == MODIFY_EXPR
1256 && MOVE_NONTEMPORAL (node
))
1257 pp_string (buffer
, "{nt}");
1259 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
,
1264 pp_string (buffer
, "TARGET_EXPR <");
1265 dump_generic_node (buffer
, TARGET_EXPR_SLOT (node
), spc
, flags
, false);
1266 pp_character (buffer
, ',');
1268 dump_generic_node (buffer
, TARGET_EXPR_INITIAL (node
), spc
, flags
, false);
1269 pp_character (buffer
, '>');
1273 print_declaration (buffer
, DECL_EXPR_DECL (node
), spc
, flags
);
1278 if (TREE_TYPE (node
) == NULL
|| TREE_TYPE (node
) == void_type_node
)
1280 pp_string (buffer
, "if (");
1281 dump_generic_node (buffer
, COND_EXPR_COND (node
), spc
, flags
, false);
1282 pp_character (buffer
, ')');
1283 /* The lowered cond_exprs should always be printed in full. */
1284 if (COND_EXPR_THEN (node
)
1285 && (IS_EMPTY_STMT (COND_EXPR_THEN (node
))
1286 || TREE_CODE (COND_EXPR_THEN (node
)) == GOTO_EXPR
)
1287 && COND_EXPR_ELSE (node
)
1288 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node
))
1289 || TREE_CODE (COND_EXPR_ELSE (node
)) == GOTO_EXPR
))
1292 dump_generic_node (buffer
, COND_EXPR_THEN (node
),
1294 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1296 pp_string (buffer
, " else ");
1297 dump_generic_node (buffer
, COND_EXPR_ELSE (node
),
1301 else if (!(flags
& TDF_SLIM
))
1303 /* Output COND_EXPR_THEN. */
1304 if (COND_EXPR_THEN (node
))
1306 newline_and_indent (buffer
, spc
+2);
1307 pp_character (buffer
, '{');
1308 newline_and_indent (buffer
, spc
+4);
1309 dump_generic_node (buffer
, COND_EXPR_THEN (node
), spc
+4,
1311 newline_and_indent (buffer
, spc
+2);
1312 pp_character (buffer
, '}');
1315 /* Output COND_EXPR_ELSE. */
1316 if (COND_EXPR_ELSE (node
)
1317 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node
)))
1319 newline_and_indent (buffer
, spc
);
1320 pp_string (buffer
, "else");
1321 newline_and_indent (buffer
, spc
+2);
1322 pp_character (buffer
, '{');
1323 newline_and_indent (buffer
, spc
+4);
1324 dump_generic_node (buffer
, COND_EXPR_ELSE (node
), spc
+4,
1326 newline_and_indent (buffer
, spc
+2);
1327 pp_character (buffer
, '}');
1334 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1336 pp_character (buffer
, '?');
1338 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1340 pp_character (buffer
, ':');
1342 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1347 pp_character (buffer
, '{');
1348 if (!(flags
& TDF_SLIM
))
1350 if (BIND_EXPR_VARS (node
))
1352 pp_newline (buffer
);
1354 for (op0
= BIND_EXPR_VARS (node
); op0
; op0
= TREE_CHAIN (op0
))
1356 print_declaration (buffer
, op0
, spc
+2, flags
);
1357 pp_newline (buffer
);
1361 newline_and_indent (buffer
, spc
+2);
1362 dump_generic_node (buffer
, BIND_EXPR_BODY (node
), spc
+2, flags
, true);
1363 newline_and_indent (buffer
, spc
);
1364 pp_character (buffer
, '}');
1370 print_call_name (buffer
, CALL_EXPR_FN (node
), flags
);
1372 /* Print parameters. */
1374 pp_character (buffer
, '(');
1377 call_expr_arg_iterator iter
;
1378 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, node
)
1380 dump_generic_node (buffer
, arg
, spc
, flags
, false);
1381 if (more_call_expr_args_p (&iter
))
1383 pp_character (buffer
, ',');
1388 if (CALL_EXPR_VA_ARG_PACK (node
))
1390 if (call_expr_nargs (node
) > 0)
1392 pp_character (buffer
, ',');
1395 pp_string (buffer
, "__builtin_va_arg_pack ()");
1397 pp_character (buffer
, ')');
1399 op1
= CALL_EXPR_STATIC_CHAIN (node
);
1402 pp_string (buffer
, " [static-chain: ");
1403 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1404 pp_character (buffer
, ']');
1407 if (CALL_EXPR_RETURN_SLOT_OPT (node
))
1408 pp_string (buffer
, " [return slot optimization]");
1409 if (CALL_EXPR_TAILCALL (node
))
1410 pp_string (buffer
, " [tail call]");
1413 case WITH_CLEANUP_EXPR
:
1417 case CLEANUP_POINT_EXPR
:
1418 pp_string (buffer
, "<<cleanup_point ");
1419 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1420 pp_string (buffer
, ">>");
1423 case PLACEHOLDER_EXPR
:
1424 pp_string (buffer
, "<PLACEHOLDER_EXPR ");
1425 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1426 pp_character (buffer
, '>');
1429 /* Binary arithmetic and logic expressions. */
1430 case WIDEN_SUM_EXPR
:
1431 case WIDEN_MULT_EXPR
:
1434 case POINTER_PLUS_EXPR
:
1436 case TRUNC_DIV_EXPR
:
1438 case FLOOR_DIV_EXPR
:
1439 case ROUND_DIV_EXPR
:
1440 case TRUNC_MOD_EXPR
:
1442 case FLOOR_MOD_EXPR
:
1443 case ROUND_MOD_EXPR
:
1445 case EXACT_DIV_EXPR
:
1450 case VEC_LSHIFT_EXPR
:
1451 case VEC_RSHIFT_EXPR
:
1455 case TRUTH_ANDIF_EXPR
:
1456 case TRUTH_ORIF_EXPR
:
1457 case TRUTH_AND_EXPR
:
1459 case TRUTH_XOR_EXPR
:
1473 case UNORDERED_EXPR
:
1475 const char *op
= op_symbol (node
);
1476 op0
= TREE_OPERAND (node
, 0);
1477 op1
= TREE_OPERAND (node
, 1);
1479 /* When the operands are expressions with less priority,
1480 keep semantics of the tree representation. */
1481 if (op_prio (op0
) <= op_prio (node
))
1483 pp_character (buffer
, '(');
1484 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1485 pp_character (buffer
, ')');
1488 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1491 pp_string (buffer
, op
);
1494 /* When the operands are expressions with less priority,
1495 keep semantics of the tree representation. */
1496 if (op_prio (op1
) <= op_prio (node
))
1498 pp_character (buffer
, '(');
1499 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1500 pp_character (buffer
, ')');
1503 dump_generic_node (buffer
, op1
, spc
, flags
, false);
1507 /* Unary arithmetic and logic expressions. */
1510 case TRUTH_NOT_EXPR
:
1512 case PREDECREMENT_EXPR
:
1513 case PREINCREMENT_EXPR
:
1514 case ALIGN_INDIRECT_REF
:
1515 case MISALIGNED_INDIRECT_REF
:
1517 if (TREE_CODE (node
) == ADDR_EXPR
1518 && (TREE_CODE (TREE_OPERAND (node
, 0)) == STRING_CST
1519 || TREE_CODE (TREE_OPERAND (node
, 0)) == FUNCTION_DECL
))
1520 ; /* Do not output '&' for strings and function pointers. */
1522 pp_string (buffer
, op_symbol (node
));
1524 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1526 pp_character (buffer
, '(');
1527 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1528 pp_character (buffer
, ')');
1531 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1533 if (TREE_CODE (node
) == MISALIGNED_INDIRECT_REF
)
1535 pp_string (buffer
, "{misalignment: ");
1536 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1537 pp_character (buffer
, '}');
1541 case POSTDECREMENT_EXPR
:
1542 case POSTINCREMENT_EXPR
:
1543 if (op_prio (TREE_OPERAND (node
, 0)) < op_prio (node
))
1545 pp_character (buffer
, '(');
1546 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1547 pp_character (buffer
, ')');
1550 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1551 pp_string (buffer
, op_symbol (node
));
1555 pp_string (buffer
, "MIN_EXPR <");
1556 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1557 pp_string (buffer
, ", ");
1558 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1559 pp_character (buffer
, '>');
1563 pp_string (buffer
, "MAX_EXPR <");
1564 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1565 pp_string (buffer
, ", ");
1566 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1567 pp_character (buffer
, '>');
1571 pp_string (buffer
, "ABS_EXPR <");
1572 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1573 pp_character (buffer
, '>');
1580 case ADDR_SPACE_CONVERT_EXPR
:
1581 case FIXED_CONVERT_EXPR
:
1582 case FIX_TRUNC_EXPR
:
1585 type
= TREE_TYPE (node
);
1586 op0
= TREE_OPERAND (node
, 0);
1587 if (type
!= TREE_TYPE (op0
))
1589 pp_character (buffer
, '(');
1590 dump_generic_node (buffer
, type
, spc
, flags
, false);
1591 pp_string (buffer
, ") ");
1593 if (op_prio (op0
) < op_prio (node
))
1594 pp_character (buffer
, '(');
1595 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1596 if (op_prio (op0
) < op_prio (node
))
1597 pp_character (buffer
, ')');
1600 case VIEW_CONVERT_EXPR
:
1601 pp_string (buffer
, "VIEW_CONVERT_EXPR<");
1602 dump_generic_node (buffer
, TREE_TYPE (node
), spc
, flags
, false);
1603 pp_string (buffer
, ">(");
1604 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1605 pp_character (buffer
, ')');
1609 pp_string (buffer
, "((");
1610 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1611 pp_string (buffer
, "))");
1614 case NON_LVALUE_EXPR
:
1615 pp_string (buffer
, "NON_LVALUE_EXPR <");
1616 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1617 pp_character (buffer
, '>');
1621 pp_string (buffer
, "SAVE_EXPR <");
1622 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1623 pp_character (buffer
, '>');
1627 pp_string (buffer
, "COMPLEX_EXPR <");
1628 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1629 pp_string (buffer
, ", ");
1630 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1631 pp_string (buffer
, ">");
1635 pp_string (buffer
, "CONJ_EXPR <");
1636 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1637 pp_string (buffer
, ">");
1641 pp_string (buffer
, "REALPART_EXPR <");
1642 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1643 pp_string (buffer
, ">");
1647 pp_string (buffer
, "IMAGPART_EXPR <");
1648 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1649 pp_string (buffer
, ">");
1653 pp_string (buffer
, "VA_ARG_EXPR <");
1654 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1655 pp_string (buffer
, ">");
1658 case TRY_FINALLY_EXPR
:
1659 case TRY_CATCH_EXPR
:
1660 pp_string (buffer
, "try");
1661 newline_and_indent (buffer
, spc
+2);
1662 pp_string (buffer
, "{");
1663 newline_and_indent (buffer
, spc
+4);
1664 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
+4, flags
, true);
1665 newline_and_indent (buffer
, spc
+2);
1666 pp_string (buffer
, "}");
1667 newline_and_indent (buffer
, spc
);
1669 (TREE_CODE (node
) == TRY_CATCH_EXPR
) ? "catch" : "finally");
1670 newline_and_indent (buffer
, spc
+2);
1671 pp_string (buffer
, "{");
1672 newline_and_indent (buffer
, spc
+4);
1673 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
+4, flags
, true);
1674 newline_and_indent (buffer
, spc
+2);
1675 pp_string (buffer
, "}");
1680 pp_string (buffer
, "catch (");
1681 dump_generic_node (buffer
, CATCH_TYPES (node
), spc
+2, flags
, false);
1682 pp_string (buffer
, ")");
1683 newline_and_indent (buffer
, spc
+2);
1684 pp_string (buffer
, "{");
1685 newline_and_indent (buffer
, spc
+4);
1686 dump_generic_node (buffer
, CATCH_BODY (node
), spc
+4, flags
, true);
1687 newline_and_indent (buffer
, spc
+2);
1688 pp_string (buffer
, "}");
1692 case EH_FILTER_EXPR
:
1693 pp_string (buffer
, "<<<eh_filter (");
1694 dump_generic_node (buffer
, EH_FILTER_TYPES (node
), spc
+2, flags
, false);
1695 pp_string (buffer
, ")>>>");
1696 newline_and_indent (buffer
, spc
+2);
1697 pp_string (buffer
, "{");
1698 newline_and_indent (buffer
, spc
+4);
1699 dump_generic_node (buffer
, EH_FILTER_FAILURE (node
), spc
+4, flags
, true);
1700 newline_and_indent (buffer
, spc
+2);
1701 pp_string (buffer
, "}");
1706 op0
= TREE_OPERAND (node
, 0);
1707 /* If this is for break or continue, don't bother printing it. */
1708 if (DECL_NAME (op0
))
1710 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
1711 if (strcmp (name
, "break") == 0
1712 || strcmp (name
, "continue") == 0)
1715 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1716 pp_character (buffer
, ':');
1717 if (DECL_NONLOCAL (op0
))
1718 pp_string (buffer
, " [non-local]");
1722 pp_string (buffer
, "while (1)");
1723 if (!(flags
& TDF_SLIM
))
1725 newline_and_indent (buffer
, spc
+2);
1726 pp_character (buffer
, '{');
1727 newline_and_indent (buffer
, spc
+4);
1728 dump_generic_node (buffer
, LOOP_EXPR_BODY (node
), spc
+4, flags
, true);
1729 newline_and_indent (buffer
, spc
+2);
1730 pp_character (buffer
, '}');
1736 pp_string (buffer
, "// predicted ");
1737 if (PREDICT_EXPR_OUTCOME (node
))
1738 pp_string (buffer
, "likely by ");
1740 pp_string (buffer
, "unlikely by ");
1741 pp_string (buffer
, predictor_name (PREDICT_EXPR_PREDICTOR (node
)));
1742 pp_string (buffer
, " predictor.");
1746 pp_string (buffer
, "return");
1747 op0
= TREE_OPERAND (node
, 0);
1751 if (TREE_CODE (op0
) == MODIFY_EXPR
)
1752 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1),
1755 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1760 pp_string (buffer
, "if (");
1761 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1762 pp_string (buffer
, ") break");
1766 pp_string (buffer
, "switch (");
1767 dump_generic_node (buffer
, SWITCH_COND (node
), spc
, flags
, false);
1768 pp_character (buffer
, ')');
1769 if (!(flags
& TDF_SLIM
))
1771 newline_and_indent (buffer
, spc
+2);
1772 pp_character (buffer
, '{');
1773 if (SWITCH_BODY (node
))
1775 newline_and_indent (buffer
, spc
+4);
1776 dump_generic_node (buffer
, SWITCH_BODY (node
), spc
+4, flags
,
1781 tree vec
= SWITCH_LABELS (node
);
1782 size_t i
, n
= TREE_VEC_LENGTH (vec
);
1783 for (i
= 0; i
< n
; ++i
)
1785 tree elt
= TREE_VEC_ELT (vec
, i
);
1786 newline_and_indent (buffer
, spc
+4);
1789 dump_generic_node (buffer
, elt
, spc
+4, flags
, false);
1790 pp_string (buffer
, " goto ");
1791 dump_generic_node (buffer
, CASE_LABEL (elt
), spc
+4,
1793 pp_semicolon (buffer
);
1796 pp_string (buffer
, "case ???: goto ???;");
1799 newline_and_indent (buffer
, spc
+2);
1800 pp_character (buffer
, '}');
1806 op0
= GOTO_DESTINATION (node
);
1807 if (TREE_CODE (op0
) != SSA_NAME
&& DECL_P (op0
) && DECL_NAME (op0
))
1809 const char *name
= IDENTIFIER_POINTER (DECL_NAME (op0
));
1810 if (strcmp (name
, "break") == 0
1811 || strcmp (name
, "continue") == 0)
1813 pp_string (buffer
, name
);
1817 pp_string (buffer
, "goto ");
1818 dump_generic_node (buffer
, op0
, spc
, flags
, false);
1822 pp_string (buffer
, "__asm__");
1823 if (ASM_VOLATILE_P (node
))
1824 pp_string (buffer
, " __volatile__");
1825 pp_character (buffer
, '(');
1826 dump_generic_node (buffer
, ASM_STRING (node
), spc
, flags
, false);
1827 pp_character (buffer
, ':');
1828 dump_generic_node (buffer
, ASM_OUTPUTS (node
), spc
, flags
, false);
1829 pp_character (buffer
, ':');
1830 dump_generic_node (buffer
, ASM_INPUTS (node
), spc
, flags
, false);
1831 if (ASM_CLOBBERS (node
))
1833 pp_character (buffer
, ':');
1834 dump_generic_node (buffer
, ASM_CLOBBERS (node
), spc
, flags
, false);
1836 pp_string (buffer
, ")");
1839 case CASE_LABEL_EXPR
:
1840 if (CASE_LOW (node
) && CASE_HIGH (node
))
1842 pp_string (buffer
, "case ");
1843 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
1844 pp_string (buffer
, " ... ");
1845 dump_generic_node (buffer
, CASE_HIGH (node
), spc
, flags
, false);
1847 else if (CASE_LOW (node
))
1849 pp_string (buffer
, "case ");
1850 dump_generic_node (buffer
, CASE_LOW (node
), spc
, flags
, false);
1853 pp_string (buffer
, "default");
1854 pp_character (buffer
, ':');
1858 pp_string (buffer
, "OBJ_TYPE_REF(");
1859 dump_generic_node (buffer
, OBJ_TYPE_REF_EXPR (node
), spc
, flags
, false);
1860 pp_character (buffer
, ';');
1861 dump_generic_node (buffer
, OBJ_TYPE_REF_OBJECT (node
), spc
, flags
, false);
1862 pp_character (buffer
, '-');
1863 pp_character (buffer
, '>');
1864 dump_generic_node (buffer
, OBJ_TYPE_REF_TOKEN (node
), spc
, flags
, false);
1865 pp_character (buffer
, ')');
1869 dump_generic_node (buffer
, SSA_NAME_VAR (node
), spc
, flags
, false);
1870 pp_string (buffer
, "_");
1871 pp_decimal_int (buffer
, SSA_NAME_VERSION (node
));
1872 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
1873 pp_string (buffer
, "(ab)");
1874 else if (SSA_NAME_IS_DEFAULT_DEF (node
))
1875 pp_string (buffer
, "(D)");
1878 case WITH_SIZE_EXPR
:
1879 pp_string (buffer
, "WITH_SIZE_EXPR <");
1880 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1881 pp_string (buffer
, ", ");
1882 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1883 pp_string (buffer
, ">");
1887 pp_string (buffer
, "ASSERT_EXPR <");
1888 dump_generic_node (buffer
, ASSERT_EXPR_VAR (node
), spc
, flags
, false);
1889 pp_string (buffer
, ", ");
1890 dump_generic_node (buffer
, ASSERT_EXPR_COND (node
), spc
, flags
, false);
1891 pp_string (buffer
, ">");
1895 pp_string (buffer
, "scev_known");
1898 case SCEV_NOT_KNOWN
:
1899 pp_string (buffer
, "scev_not_known");
1902 case POLYNOMIAL_CHREC
:
1903 pp_string (buffer
, "{");
1904 dump_generic_node (buffer
, CHREC_LEFT (node
), spc
, flags
, false);
1905 pp_string (buffer
, ", +, ");
1906 dump_generic_node (buffer
, CHREC_RIGHT (node
), spc
, flags
, false);
1907 pp_string (buffer
, "}_");
1908 dump_generic_node (buffer
, CHREC_VAR (node
), spc
, flags
, false);
1912 case REALIGN_LOAD_EXPR
:
1913 pp_string (buffer
, "REALIGN_LOAD <");
1914 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1915 pp_string (buffer
, ", ");
1916 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1917 pp_string (buffer
, ", ");
1918 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1919 pp_string (buffer
, ">");
1923 pp_string (buffer
, " VEC_COND_EXPR < ");
1924 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1925 pp_string (buffer
, " , ");
1926 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1927 pp_string (buffer
, " , ");
1928 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1929 pp_string (buffer
, " > ");
1933 pp_string (buffer
, " DOT_PROD_EXPR < ");
1934 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
1935 pp_string (buffer
, ", ");
1936 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
1937 pp_string (buffer
, ", ");
1938 dump_generic_node (buffer
, TREE_OPERAND (node
, 2), spc
, flags
, false);
1939 pp_string (buffer
, " > ");
1943 pp_string (buffer
, "#pragma omp parallel");
1944 dump_omp_clauses (buffer
, OMP_PARALLEL_CLAUSES (node
), spc
, flags
);
1947 if (!(flags
& TDF_SLIM
) && OMP_BODY (node
))
1949 newline_and_indent (buffer
, spc
+ 2);
1950 pp_character (buffer
, '{');
1951 newline_and_indent (buffer
, spc
+ 4);
1952 dump_generic_node (buffer
, OMP_BODY (node
), spc
+ 4, flags
, false);
1953 newline_and_indent (buffer
, spc
+ 2);
1954 pp_character (buffer
, '}');
1960 pp_string (buffer
, "#pragma omp task");
1961 dump_omp_clauses (buffer
, OMP_TASK_CLAUSES (node
), spc
, flags
);
1965 pp_string (buffer
, "#pragma omp for");
1966 dump_omp_clauses (buffer
, OMP_FOR_CLAUSES (node
), spc
, flags
);
1968 if (!(flags
& TDF_SLIM
))
1972 if (OMP_FOR_PRE_BODY (node
))
1974 newline_and_indent (buffer
, spc
+ 2);
1975 pp_character (buffer
, '{');
1977 newline_and_indent (buffer
, spc
);
1978 dump_generic_node (buffer
, OMP_FOR_PRE_BODY (node
),
1982 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (node
)); i
++)
1985 newline_and_indent (buffer
, spc
);
1986 pp_string (buffer
, "for (");
1987 dump_generic_node (buffer
, TREE_VEC_ELT (OMP_FOR_INIT (node
), i
),
1989 pp_string (buffer
, "; ");
1990 dump_generic_node (buffer
, TREE_VEC_ELT (OMP_FOR_COND (node
), i
),
1992 pp_string (buffer
, "; ");
1993 dump_generic_node (buffer
, TREE_VEC_ELT (OMP_FOR_INCR (node
), i
),
1995 pp_string (buffer
, ")");
1997 if (OMP_FOR_BODY (node
))
1999 newline_and_indent (buffer
, spc
+ 2);
2000 pp_character (buffer
, '{');
2001 newline_and_indent (buffer
, spc
+ 4);
2002 dump_generic_node (buffer
, OMP_FOR_BODY (node
), spc
+ 4, flags
,
2004 newline_and_indent (buffer
, spc
+ 2);
2005 pp_character (buffer
, '}');
2007 spc
-= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node
)) - 2;
2008 if (OMP_FOR_PRE_BODY (node
))
2011 newline_and_indent (buffer
, spc
+ 2);
2012 pp_character (buffer
, '}');
2019 pp_string (buffer
, "#pragma omp sections");
2020 dump_omp_clauses (buffer
, OMP_SECTIONS_CLAUSES (node
), spc
, flags
);
2024 pp_string (buffer
, "#pragma omp section");
2028 pp_string (buffer
, "#pragma omp master");
2032 pp_string (buffer
, "#pragma omp ordered");
2036 pp_string (buffer
, "#pragma omp critical");
2037 if (OMP_CRITICAL_NAME (node
))
2040 pp_character (buffer
, '(');
2041 dump_generic_node (buffer
, OMP_CRITICAL_NAME (node
), spc
,
2043 pp_character (buffer
, ')');
2048 pp_string (buffer
, "#pragma omp atomic");
2049 newline_and_indent (buffer
, spc
+ 2);
2050 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2052 pp_character (buffer
, '=');
2054 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2058 pp_string (buffer
, "#pragma omp single");
2059 dump_omp_clauses (buffer
, OMP_SINGLE_CLAUSES (node
), spc
, flags
);
2063 dump_omp_clause (buffer
, node
, spc
, flags
);
2067 case REDUC_MAX_EXPR
:
2068 pp_string (buffer
, " REDUC_MAX_EXPR < ");
2069 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2070 pp_string (buffer
, " > ");
2073 case REDUC_MIN_EXPR
:
2074 pp_string (buffer
, " REDUC_MIN_EXPR < ");
2075 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2076 pp_string (buffer
, " > ");
2079 case REDUC_PLUS_EXPR
:
2080 pp_string (buffer
, " REDUC_PLUS_EXPR < ");
2081 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2082 pp_string (buffer
, " > ");
2085 case VEC_WIDEN_MULT_HI_EXPR
:
2086 pp_string (buffer
, " VEC_WIDEN_MULT_HI_EXPR < ");
2087 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2088 pp_string (buffer
, ", ");
2089 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2090 pp_string (buffer
, " > ");
2093 case VEC_WIDEN_MULT_LO_EXPR
:
2094 pp_string (buffer
, " VEC_WIDEN_MULT_LO_EXPR < ");
2095 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2096 pp_string (buffer
, ", ");
2097 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2098 pp_string (buffer
, " > ");
2101 case VEC_UNPACK_HI_EXPR
:
2102 pp_string (buffer
, " VEC_UNPACK_HI_EXPR < ");
2103 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2104 pp_string (buffer
, " > ");
2107 case VEC_UNPACK_LO_EXPR
:
2108 pp_string (buffer
, " VEC_UNPACK_LO_EXPR < ");
2109 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2110 pp_string (buffer
, " > ");
2113 case VEC_UNPACK_FLOAT_HI_EXPR
:
2114 pp_string (buffer
, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2115 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2116 pp_string (buffer
, " > ");
2119 case VEC_UNPACK_FLOAT_LO_EXPR
:
2120 pp_string (buffer
, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2121 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2122 pp_string (buffer
, " > ");
2125 case VEC_PACK_TRUNC_EXPR
:
2126 pp_string (buffer
, " VEC_PACK_TRUNC_EXPR < ");
2127 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2128 pp_string (buffer
, ", ");
2129 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2130 pp_string (buffer
, " > ");
2133 case VEC_PACK_SAT_EXPR
:
2134 pp_string (buffer
, " VEC_PACK_SAT_EXPR < ");
2135 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2136 pp_string (buffer
, ", ");
2137 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2138 pp_string (buffer
, " > ");
2141 case VEC_PACK_FIX_TRUNC_EXPR
:
2142 pp_string (buffer
, " VEC_PACK_FIX_TRUNC_EXPR < ");
2143 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2144 pp_string (buffer
, ", ");
2145 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2146 pp_string (buffer
, " > ");
2150 dump_block_node (buffer
, node
, spc
, flags
);
2153 case VEC_EXTRACT_EVEN_EXPR
:
2154 pp_string (buffer
, " VEC_EXTRACT_EVEN_EXPR < ");
2155 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2156 pp_string (buffer
, ", ");
2157 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2158 pp_string (buffer
, " > ");
2161 case VEC_EXTRACT_ODD_EXPR
:
2162 pp_string (buffer
, " VEC_EXTRACT_ODD_EXPR < ");
2163 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2164 pp_string (buffer
, ", ");
2165 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2166 pp_string (buffer
, " > ");
2169 case VEC_INTERLEAVE_HIGH_EXPR
:
2170 pp_string (buffer
, " VEC_INTERLEAVE_HIGH_EXPR < ");
2171 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2172 pp_string (buffer
, ", ");
2173 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2174 pp_string (buffer
, " > ");
2177 case VEC_INTERLEAVE_LOW_EXPR
:
2178 pp_string (buffer
, " VEC_INTERLEAVE_LOW_EXPR < ");
2179 dump_generic_node (buffer
, TREE_OPERAND (node
, 0), spc
, flags
, false);
2180 pp_string (buffer
, ", ");
2181 dump_generic_node (buffer
, TREE_OPERAND (node
, 1), spc
, flags
, false);
2182 pp_string (buffer
, " > ");
2189 if (is_stmt
&& is_expr
)
2190 pp_semicolon (buffer
);
2192 /* If we're building a diagnostic, the formatted text will be written
2193 into BUFFER's stream by the caller; otherwise, write it now. */
2194 if (!(flags
& TDF_DIAGNOSTIC
))
2195 pp_write_text_to_stream (buffer
);
2200 /* Print the declaration of a variable. */
2203 print_declaration (pretty_printer
*buffer
, tree t
, int spc
, int flags
)
2207 if (TREE_CODE (t
) == TYPE_DECL
)
2208 pp_string (buffer
, "typedef ");
2210 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
) && DECL_REGISTER (t
))
2211 pp_string (buffer
, "register ");
2213 if (TREE_PUBLIC (t
) && DECL_EXTERNAL (t
))
2214 pp_string (buffer
, "extern ");
2215 else if (TREE_STATIC (t
))
2216 pp_string (buffer
, "static ");
2218 /* Print the type and name. */
2219 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
2223 /* Print array's type. */
2224 tmp
= TREE_TYPE (t
);
2225 while (TREE_CODE (TREE_TYPE (tmp
)) == ARRAY_TYPE
)
2226 tmp
= TREE_TYPE (tmp
);
2227 dump_generic_node (buffer
, TREE_TYPE (tmp
), spc
, flags
, false);
2229 /* Print variable's name. */
2231 dump_generic_node (buffer
, t
, spc
, flags
, false);
2233 /* Print the dimensions. */
2234 tmp
= TREE_TYPE (t
);
2235 while (TREE_CODE (tmp
) == ARRAY_TYPE
)
2237 dump_array_domain (buffer
, TYPE_DOMAIN (tmp
), spc
, flags
);
2238 tmp
= TREE_TYPE (tmp
);
2241 else if (TREE_CODE (t
) == FUNCTION_DECL
)
2243 dump_generic_node (buffer
, TREE_TYPE (TREE_TYPE (t
)), spc
, flags
, false);
2245 dump_decl_name (buffer
, t
, flags
);
2246 dump_function_declaration (buffer
, TREE_TYPE (t
), spc
, flags
);
2250 /* Print type declaration. */
2251 dump_generic_node (buffer
, TREE_TYPE (t
), spc
, flags
, false);
2253 /* Print variable's name. */
2255 dump_generic_node (buffer
, t
, spc
, flags
, false);
2258 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
2260 pp_string (buffer
, " __asm__ ");
2261 pp_character (buffer
, '(');
2262 dump_generic_node (buffer
, DECL_ASSEMBLER_NAME (t
), spc
, flags
, false);
2263 pp_character (buffer
, ')');
2266 /* The initial value of a function serves to determine whether the function
2267 is declared or defined. So the following does not apply to function
2269 if (TREE_CODE (t
) != FUNCTION_DECL
)
2271 /* Print the initial value. */
2272 if (DECL_INITIAL (t
))
2275 pp_character (buffer
, '=');
2277 dump_generic_node (buffer
, DECL_INITIAL (t
), spc
, flags
, false);
2281 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
2283 pp_string (buffer
, " [value-expr: ");
2284 dump_generic_node (buffer
, DECL_VALUE_EXPR (t
), spc
, flags
, false);
2285 pp_character (buffer
, ']');
2288 pp_character (buffer
, ';');
2292 /* Prints a structure: name, fields, and methods.
2293 FIXME: Still incomplete. */
2296 print_struct_decl (pretty_printer
*buffer
, const_tree node
, int spc
, int flags
)
2298 /* Print the name of the structure. */
2299 if (TYPE_NAME (node
))
2302 if (TREE_CODE (node
) == RECORD_TYPE
)
2303 pp_string (buffer
, "struct ");
2304 else if ((TREE_CODE (node
) == UNION_TYPE
2305 || TREE_CODE (node
) == QUAL_UNION_TYPE
))
2306 pp_string (buffer
, "union ");
2308 dump_generic_node (buffer
, TYPE_NAME (node
), spc
, 0, false);
2311 /* Print the contents of the structure. */
2312 pp_newline (buffer
);
2314 pp_character (buffer
, '{');
2315 pp_newline (buffer
);
2317 /* Print the fields of the structure. */
2320 tmp
= TYPE_FIELDS (node
);
2323 /* Avoid to print recursively the structure. */
2324 /* FIXME : Not implemented correctly...,
2325 what about the case when we have a cycle in the contain graph? ...
2326 Maybe this could be solved by looking at the scope in which the
2327 structure was declared. */
2328 if (TREE_TYPE (tmp
) != node
2329 && (TREE_CODE (TREE_TYPE (tmp
)) != POINTER_TYPE
2330 || TREE_TYPE (TREE_TYPE (tmp
)) != node
))
2332 print_declaration (buffer
, tmp
, spc
+2, flags
);
2333 pp_newline (buffer
);
2335 tmp
= TREE_CHAIN (tmp
);
2339 pp_character (buffer
, '}');
2342 /* Return the priority of the operator CODE.
2344 From lowest to highest precedence with either left-to-right (L-R)
2345 or right-to-left (R-L) associativity]:
2348 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2360 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2361 15 [L-R] fn() [] -> .
2363 unary +, - and * have higher precedence than the corresponding binary
2367 op_code_prio (enum tree_code code
)
2384 case TRUTH_ORIF_EXPR
:
2387 case TRUTH_AND_EXPR
:
2388 case TRUTH_ANDIF_EXPR
:
2395 case TRUTH_XOR_EXPR
:
2412 case UNORDERED_EXPR
:
2425 case WIDEN_SUM_EXPR
:
2427 case POINTER_PLUS_EXPR
:
2431 case VEC_WIDEN_MULT_HI_EXPR
:
2432 case VEC_WIDEN_MULT_LO_EXPR
:
2433 case WIDEN_MULT_EXPR
:
2436 case TRUNC_DIV_EXPR
:
2438 case FLOOR_DIV_EXPR
:
2439 case ROUND_DIV_EXPR
:
2441 case EXACT_DIV_EXPR
:
2442 case TRUNC_MOD_EXPR
:
2444 case FLOOR_MOD_EXPR
:
2445 case ROUND_MOD_EXPR
:
2448 case TRUTH_NOT_EXPR
:
2450 case POSTINCREMENT_EXPR
:
2451 case POSTDECREMENT_EXPR
:
2452 case PREINCREMENT_EXPR
:
2453 case PREDECREMENT_EXPR
:
2455 case ALIGN_INDIRECT_REF
:
2456 case MISALIGNED_INDIRECT_REF
:
2461 case FIX_TRUNC_EXPR
:
2467 case ARRAY_RANGE_REF
:
2471 /* Special expressions. */
2477 case REDUC_MAX_EXPR
:
2478 case REDUC_MIN_EXPR
:
2479 case REDUC_PLUS_EXPR
:
2480 case VEC_LSHIFT_EXPR
:
2481 case VEC_RSHIFT_EXPR
:
2482 case VEC_UNPACK_HI_EXPR
:
2483 case VEC_UNPACK_LO_EXPR
:
2484 case VEC_UNPACK_FLOAT_HI_EXPR
:
2485 case VEC_UNPACK_FLOAT_LO_EXPR
:
2486 case VEC_PACK_TRUNC_EXPR
:
2487 case VEC_PACK_SAT_EXPR
:
2491 /* Return an arbitrarily high precedence to avoid surrounding single
2492 VAR_DECLs in ()s. */
2497 /* Return the priority of the operator OP. */
2500 op_prio (const_tree op
)
2502 enum tree_code code
;
2507 code
= TREE_CODE (op
);
2508 if (code
== SAVE_EXPR
|| code
== NON_LVALUE_EXPR
)
2509 return op_prio (TREE_OPERAND (op
, 0));
2511 return op_code_prio (code
);
2514 /* Return the symbol associated with operator CODE. */
2517 op_symbol_code (enum tree_code code
)
2525 case TRUTH_ORIF_EXPR
:
2528 case TRUTH_AND_EXPR
:
2529 case TRUTH_ANDIF_EXPR
:
2535 case TRUTH_XOR_EXPR
:
2545 case UNORDERED_EXPR
:
2591 case VEC_LSHIFT_EXPR
:
2594 case VEC_RSHIFT_EXPR
:
2597 case POINTER_PLUS_EXPR
:
2603 case REDUC_PLUS_EXPR
:
2606 case WIDEN_SUM_EXPR
:
2609 case WIDEN_MULT_EXPR
:
2619 case TRUTH_NOT_EXPR
:
2626 case ALIGN_INDIRECT_REF
:
2629 case MISALIGNED_INDIRECT_REF
:
2632 case TRUNC_DIV_EXPR
:
2639 case FLOOR_DIV_EXPR
:
2642 case ROUND_DIV_EXPR
:
2645 case EXACT_DIV_EXPR
:
2648 case TRUNC_MOD_EXPR
:
2654 case FLOOR_MOD_EXPR
:
2657 case ROUND_MOD_EXPR
:
2660 case PREDECREMENT_EXPR
:
2663 case PREINCREMENT_EXPR
:
2666 case POSTDECREMENT_EXPR
:
2669 case POSTINCREMENT_EXPR
:
2679 return "<<< ??? >>>";
2683 /* Return the symbol associated with operator OP. */
2686 op_symbol (const_tree op
)
2688 return op_symbol_code (TREE_CODE (op
));
2691 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
2692 the gimple_call_fn of a GIMPLE_CALL. */
2695 print_call_name (pretty_printer
*buffer
, tree node
, int flags
)
2699 if (TREE_CODE (op0
) == NON_LVALUE_EXPR
)
2700 op0
= TREE_OPERAND (op0
, 0);
2703 switch (TREE_CODE (op0
))
2708 dump_function_name (buffer
, op0
, flags
);
2714 op0
= TREE_OPERAND (op0
, 0);
2718 pp_string (buffer
, "(");
2719 dump_generic_node (buffer
, TREE_OPERAND (op0
, 0), 0, flags
, false);
2720 pp_string (buffer
, ") ? ");
2721 dump_generic_node (buffer
, TREE_OPERAND (op0
, 1), 0, flags
, false);
2722 pp_string (buffer
, " : ");
2723 dump_generic_node (buffer
, TREE_OPERAND (op0
, 2), 0, flags
, false);
2727 if (TREE_CODE (TREE_OPERAND (op0
, 0)) == VAR_DECL
)
2728 dump_function_name (buffer
, TREE_OPERAND (op0
, 0), flags
);
2730 dump_generic_node (buffer
, op0
, 0, flags
, false);
2736 dump_generic_node (buffer
, op0
, 0, flags
, false);
2744 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2747 pretty_print_string (pretty_printer
*buffer
, const char *str
)
2757 pp_string (buffer
, "\\b");
2761 pp_string (buffer
, "\\f");
2765 pp_string (buffer
, "\\n");
2769 pp_string (buffer
, "\\r");
2773 pp_string (buffer
, "\\t");
2777 pp_string (buffer
, "\\v");
2781 pp_string (buffer
, "\\\\");
2785 pp_string (buffer
, "\\\"");
2789 pp_string (buffer
, "\\'");
2792 /* No need to handle \0; the loop terminates on \0. */
2795 pp_string (buffer
, "\\1");
2799 pp_string (buffer
, "\\2");
2803 pp_string (buffer
, "\\3");
2807 pp_string (buffer
, "\\4");
2811 pp_string (buffer
, "\\5");
2815 pp_string (buffer
, "\\6");
2819 pp_string (buffer
, "\\7");
2823 pp_character (buffer
, str
[0]);
2831 maybe_init_pretty_print (FILE *file
)
2835 pp_construct (&buffer
, /* prefix */NULL
, /* line-width */0);
2836 pp_needs_newline (&buffer
) = true;
2837 pp_translate_identifiers (&buffer
) = false;
2841 buffer
.buffer
->stream
= file
;
2845 newline_and_indent (pretty_printer
*buffer
, int spc
)
2847 pp_newline (buffer
);