?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
EnumSet*.class: Regenerate
[official-gcc.git] / gcc / tree-pretty-print.c
blob738fb0938c2c2b309da65f3bba31502f07a3e438
1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
4 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
5
6 This file is part of GCC.
7
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
11 version.
12
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
16 for more details.
17
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/>. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "tree.h"
27 #include "diagnostic.h"
28 #include "real.h"
29 #include "hashtab.h"
30 #include "tree-flow.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
33 #include "tree-chrec.h"
34 #include "tree-pass.h"
35 #include "fixed-value.h"
36 #include "value-prof.h"
37
38 /* Local functions, macros and variables. */
39 static int op_prio (const_tree);
40 static const char *op_symbol (tree);
41 static void pretty_print_string (pretty_printer *, const char*);
42 static void print_call_name (pretty_printer *, tree);
43 static void newline_and_indent (pretty_printer *, int);
44 static void maybe_init_pretty_print (FILE *);
45 static void print_declaration (pretty_printer *, tree, int, int);
46 static void print_struct_decl (pretty_printer *, tree, int, int);
47 static void do_niy (pretty_printer *, tree);
48 static void dump_vops (pretty_printer *, tree, int, int);
49 static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
50
51 #define INDENT(SPACE) do { \
52 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
53
54 #define NIY do_niy(buffer,node)
55
56 #define PRINT_FUNCTION_NAME(NODE) pp_printf \
57 (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \
58 lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
59 lang_hooks.decl_printable_name (NODE, 1))
60
61 static pretty_printer buffer;
62 static int initialized = 0;
63
64 /* Try to print something for an unknown tree code. */
65
66 static void
67 do_niy (pretty_printer *buffer, tree node)
68 {
69 int i, len;
70
71 pp_string (buffer, "<<< Unknown tree: ");
72 pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
73
74 if (EXPR_P (node))
75 {
76 len = TREE_OPERAND_LENGTH (node);
77 for (i = 0; i < len; ++i)
78 {
79 newline_and_indent (buffer, 2);
80 dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);
81 }
82 }
83
84 pp_string (buffer, " >>>\n");
85 }
86
87 /* Debugging function to print out a generic expression. */
88
89 void
90 debug_generic_expr (tree t)
91 {
92 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
93 fprintf (stderr, "\n");
94 }
95
96 /* Debugging function to print out a generic statement. */
97
98 void
99 debug_generic_stmt (tree t)
100 {
101 print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
102 fprintf (stderr, "\n");
103 }
104
105 /* Debugging function to print out a chain of trees . */
106
107 void
108 debug_tree_chain (tree t)
109 {
110 while (t)
111 {
112 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
113 fprintf(stderr, " ");
114 t = TREE_CHAIN (t);
115 }
116 fprintf (stderr, "\n");
117 }
118
119 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
120 void
121 print_generic_decl (FILE *file, tree decl, int flags)
122 {
123 maybe_init_pretty_print (file);
124 print_declaration (&buffer, decl, 2, flags);
125 pp_write_text_to_stream (&buffer);
126 }
127
128 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
129 to show in the dump. See TDF_* in tree.h. */
130
131 void
132 print_generic_stmt (FILE *file, tree t, int flags)
133 {
134 maybe_init_pretty_print (file);
135 dump_generic_node (&buffer, t, 0, flags, true);
136 pp_flush (&buffer);
137 }
138
139 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
140 to show in the dump. See TDF_* in tree.h. The output is indented by
141 INDENT spaces. */
142
143 void
144 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
145 {
146 int i;
147
148 maybe_init_pretty_print (file);
149
150 for (i = 0; i < indent; i++)
151 pp_space (&buffer);
152 dump_generic_node (&buffer, t, indent, flags, true);
153 pp_flush (&buffer);
154 }
155
156 /* Print a single expression T on file FILE. FLAGS specifies details to show
157 in the dump. See TDF_* in tree.h. */
158
159 void
160 print_generic_expr (FILE *file, tree t, int flags)
161 {
162 maybe_init_pretty_print (file);
163 dump_generic_node (&buffer, t, 0, flags, false);
164 }
165
166 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
167 in FLAGS. */
168
169 static void
170 dump_decl_name (pretty_printer *buffer, tree node, int flags)
171 {
172 tree t = node;
173
174 if (DECL_NAME (t))
175 pp_tree_identifier (buffer, DECL_NAME (t));
176 if ((flags & TDF_UID)
177 || DECL_NAME (t) == NULL_TREE)
178 {
179 if (TREE_CODE (t) == LABEL_DECL
180 && LABEL_DECL_UID (t) != -1)
181 pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
182 LABEL_DECL_UID (t));
183 else
184 {
185 char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
186 pp_printf (buffer, "%c.%u", c, DECL_UID (t));
187 }
188 }
189 }
190
191 /* Like the above, but used for pretty printing function calls. */
192
193 static void
194 dump_function_name (pretty_printer *buffer, tree node)
195 {
196 if (DECL_NAME (node))
197 PRINT_FUNCTION_NAME (node);
198 else
199 dump_decl_name (buffer, node, 0);
200 }
201
202 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
203 FLAGS are as in dump_generic_node. */
204
205 static void
206 dump_function_declaration (pretty_printer *buffer, tree node,
207 int spc, int flags)
208 {
209 bool wrote_arg = false;
210 tree arg;
211
212 pp_space (buffer);
213 pp_character (buffer, '(');
214
215 /* Print the argument types. The last element in the list is a VOID_TYPE.
216 The following avoids printing the last element. */
217 arg = TYPE_ARG_TYPES (node);
218 while (arg && TREE_CHAIN (arg) && arg != error_mark_node)
219 {
220 wrote_arg = true;
221 dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
222 arg = TREE_CHAIN (arg);
223 if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)
224 {
225 pp_character (buffer, ',');
226 pp_space (buffer);
227 }
228 }
229
230 if (!wrote_arg)
231 pp_string (buffer, "void");
232
233 pp_character (buffer, ')');
234 }
235
236 /* Dump the domain associated with an array. */
237
238 static void
239 dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
240 {
241 pp_character (buffer, '[');
242 if (domain)
243 {
244 tree min = TYPE_MIN_VALUE (domain);
245 tree max = TYPE_MAX_VALUE (domain);
246
247 if (min && max
248 && integer_zerop (min)
249 && host_integerp (max, 0))
250 pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
251 else
252 {
253 if (min)
254 dump_generic_node (buffer, min, spc, flags, false);
255 pp_character (buffer, ':');
256 if (max)
257 dump_generic_node (buffer, max, spc, flags, false);
258 }
259 }
260 else
261 pp_string (buffer, "<unknown>");
262 pp_character (buffer, ']');
263 }
264
265
266 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
267 dump_generic_node. */
268
269 static void
270 dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
271 {
272 const char *name;
273
274 switch (OMP_CLAUSE_CODE (clause))
275 {
276 case OMP_CLAUSE_PRIVATE:
277 name = "private";
278 goto print_remap;
279 case OMP_CLAUSE_SHARED:
280 name = "shared";
281 goto print_remap;
282 case OMP_CLAUSE_FIRSTPRIVATE:
283 name = "firstprivate";
284 goto print_remap;
285 case OMP_CLAUSE_LASTPRIVATE:
286 name = "lastprivate";
287 goto print_remap;
288 case OMP_CLAUSE_COPYIN:
289 name = "copyin";
290 goto print_remap;
291 case OMP_CLAUSE_COPYPRIVATE:
292 name = "copyprivate";
293 goto print_remap;
294 print_remap:
295 pp_string (buffer, name);
296 pp_character (buffer, '(');
297 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
298 spc, flags, false);
299 pp_character (buffer, ')');
300 break;
301
302 case OMP_CLAUSE_REDUCTION:
303 pp_string (buffer, "reduction(");
304 pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
305 pp_character (buffer, ':');
306 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
307 spc, flags, false);
308 pp_character (buffer, ')');
309 break;
310
311 case OMP_CLAUSE_IF:
312 pp_string (buffer, "if(");
313 dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
314 spc, flags, false);
315 pp_character (buffer, ')');
316 break;
317
318 case OMP_CLAUSE_NUM_THREADS:
319 pp_string (buffer, "num_threads(");
320 dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
321 spc, flags, false);
322 pp_character (buffer, ')');
323 break;
324
325 case OMP_CLAUSE_NOWAIT:
326 pp_string (buffer, "nowait");
327 break;
328 case OMP_CLAUSE_ORDERED:
329 pp_string (buffer, "ordered");
330 break;
331
332 case OMP_CLAUSE_DEFAULT:
333 pp_string (buffer, "default(");
334 switch (OMP_CLAUSE_DEFAULT_KIND (clause))
335 {
336 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
337 break;
338 case OMP_CLAUSE_DEFAULT_SHARED:
339 pp_string (buffer, "shared");
340 break;
341 case OMP_CLAUSE_DEFAULT_NONE:
342 pp_string (buffer, "none");
343 break;
344 case OMP_CLAUSE_DEFAULT_PRIVATE:
345 pp_string (buffer, "private");
346 break;
347 default:
348 gcc_unreachable ();
349 }
350 pp_character (buffer, ')');
351 break;
352
353 case OMP_CLAUSE_SCHEDULE:
354 pp_string (buffer, "schedule(");
355 switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
356 {
357 case OMP_CLAUSE_SCHEDULE_STATIC:
358 pp_string (buffer, "static");
359 break;
360 case OMP_CLAUSE_SCHEDULE_DYNAMIC:
361 pp_string (buffer, "dynamic");
362 break;
363 case OMP_CLAUSE_SCHEDULE_GUIDED:
364 pp_string (buffer, "guided");
365 break;
366 case OMP_CLAUSE_SCHEDULE_RUNTIME:
367 pp_string (buffer, "runtime");
368 break;
369 default:
370 gcc_unreachable ();
371 }
372 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
373 {
374 pp_character (buffer, ',');
375 dump_generic_node (buffer,
376 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
377 spc, flags, false);
378 }
379 pp_character (buffer, ')');
380 break;
381
382 default:
383 /* Should never happen. */
384 dump_generic_node (buffer, clause, spc, flags, false);
385 break;
386 }
387 }
388
389
390 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
391 dump_generic_node. */
392
393 static void
394 dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
395 {
396 if (clause == NULL)
397 return;
398
399 pp_space (buffer);
400 while (1)
401 {
402 dump_omp_clause (buffer, clause, spc, flags);
403 clause = OMP_CLAUSE_CHAIN (clause);
404 if (clause == NULL)
405 return;
406 pp_space (buffer);
407 }
408 }
409
410
411 /* Dump the set of decls SYMS. BUFFER, SPC and FLAGS are as in
412 dump_generic_node. */
413
414 static void
415 dump_symbols (pretty_printer *buffer, bitmap syms, int flags)
416 {
417 unsigned i;
418 bitmap_iterator bi;
419
420 if (syms == NULL)
421 pp_string (buffer, "NIL");
422 else
423 {
424 pp_string (buffer, " { ");
425
426 EXECUTE_IF_SET_IN_BITMAP (syms, 0, i, bi)
427 {
428 tree sym = referenced_var_lookup (i);
429 dump_generic_node (buffer, sym, 0, flags, false);
430 pp_string (buffer, " ");
431 }
432
433 pp_string (buffer, "}");
434 }
435 }
436
437
438 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
439 FLAGS specifies details to show in the dump (see TDF_* in tree-pass.h).
440 If IS_STMT is true, the object printed is considered to be a statement
441 and it is terminated by ';' if appropriate. */
442
443 int
444 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
445 bool is_stmt)
446 {
447 tree type;
448 tree op0, op1;
449 const char *str;
450 bool is_expr;
451
452 if (node == NULL_TREE)
453 return spc;
454
455 is_expr = EXPR_P (node) || GIMPLE_STMT_P (node);
456
457 /* We use has_stmt_ann because CALL_EXPR can be both an expression
458 and a statement, and we have no guarantee that it will have a
459 stmt_ann when it is used as an RHS expression. stmt_ann will assert
460 if you call it on something with a non-stmt annotation attached. */
461 if (TREE_CODE (node) != ERROR_MARK
462 && is_gimple_stmt (node)
463 && (flags & (TDF_VOPS|TDF_MEMSYMS))
464 && has_stmt_ann (node)
465 && TREE_CODE (node) != PHI_NODE)
466 dump_vops (buffer, node, spc, flags);
467
468 if (is_stmt && (flags & TDF_STMTADDR))
469 pp_printf (buffer, "<&%p> ", (void *)node);
470
471 if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
472 {
473 expanded_location xloc = expand_location (EXPR_LOCATION (node));
474 pp_character (buffer, '[');
475 if (xloc.file)
476 {
477 pp_string (buffer, xloc.file);
478 pp_string (buffer, " : ");
479 }
480 pp_decimal_int (buffer, xloc.line);
481 pp_string (buffer, "] ");
482 }
483
484 switch (TREE_CODE (node))
485 {
486 case ERROR_MARK:
487 pp_string (buffer, "<<< error >>>");
488 break;
489
490 case IDENTIFIER_NODE:
491 pp_tree_identifier (buffer, node);
492 break;
493
494 case TREE_LIST:
495 while (node && node != error_mark_node)
496 {
497 if (TREE_PURPOSE (node))
498 {
499 dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
500 pp_space (buffer);
501 }
502 dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
503 node = TREE_CHAIN (node);
504 if (node && TREE_CODE (node) == TREE_LIST)
505 {
506 pp_character (buffer, ',');
507 pp_space (buffer);
508 }
509 }
510 break;
511
512 case TREE_BINFO:
513 dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
514
515 case TREE_VEC:
516 {
517 size_t i;
518 if (TREE_VEC_LENGTH (node) > 0)
519 {
520 size_t len = TREE_VEC_LENGTH (node);
521 for (i = 0; i < len - 1; i++)
522 {
523 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
524 false);
525 pp_character (buffer, ',');
526 pp_space (buffer);
527 }
528 dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
529 flags, false);
530 }
531 }
532 break;
533
534 case VOID_TYPE:
535 case INTEGER_TYPE:
536 case REAL_TYPE:
537 case FIXED_POINT_TYPE:
538 case COMPLEX_TYPE:
539 case VECTOR_TYPE:
540 case ENUMERAL_TYPE:
541 case BOOLEAN_TYPE:
542 {
543 unsigned int quals = TYPE_QUALS (node);
544 enum tree_code_class class;
545
546 if (quals & TYPE_QUAL_CONST)
547 pp_string (buffer, "const ");
548 else if (quals & TYPE_QUAL_VOLATILE)
549 pp_string (buffer, "volatile ");
550 else if (quals & TYPE_QUAL_RESTRICT)
551 pp_string (buffer, "restrict ");
552
553 class = TREE_CODE_CLASS (TREE_CODE (node));
554
555 if (class == tcc_declaration)
556 {
557 if (DECL_NAME (node))
558 dump_decl_name (buffer, node, flags);
559 else
560 pp_string (buffer, "<unnamed type decl>");
561 }
562 else if (class == tcc_type)
563 {
564 if (TYPE_NAME (node))
565 {
566 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
567 pp_tree_identifier (buffer, TYPE_NAME (node));
568 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
569 && DECL_NAME (TYPE_NAME (node)))
570 dump_decl_name (buffer, TYPE_NAME (node), flags);
571 else
572 pp_string (buffer, "<unnamed type>");
573 }
574 else if (TREE_CODE (node) == VECTOR_TYPE)
575 {
576 pp_string (buffer, "vector ");
577 dump_generic_node (buffer, TREE_TYPE (node),
578 spc, flags, false);
579 }
580 else if (TREE_CODE (node) == INTEGER_TYPE)
581 {
582 pp_string (buffer, (TYPE_UNSIGNED (node)
583 ? "<unnamed-unsigned:"
584 : "<unnamed-signed:"));
585 pp_decimal_int (buffer, TYPE_PRECISION (node));
586 pp_string (buffer, ">");
587 }
588 else
589 pp_string (buffer, "<unnamed type>");
590 }
591 break;
592 }
593
594 case POINTER_TYPE:
595 case REFERENCE_TYPE:
596 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
597
598 if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
599 {
600 tree fnode = TREE_TYPE (node);
601
602 dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
603 pp_space (buffer);
604 pp_character (buffer, '(');
605 pp_string (buffer, str);
606 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
607 dump_decl_name (buffer, TYPE_NAME (node), flags);
608 else
609 pp_printf (buffer, "<T%x>", TYPE_UID (node));
610
611 pp_character (buffer, ')');
612 dump_function_declaration (buffer, fnode, spc, flags);
613 }
614 else
615 {
616 unsigned int quals = TYPE_QUALS (node);
617
618 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
619 pp_space (buffer);
620 pp_string (buffer, str);
621
622 if (quals & TYPE_QUAL_CONST)
623 pp_string (buffer, " const");
624 else if (quals & TYPE_QUAL_VOLATILE)
625 pp_string (buffer, "volatile");
626 else if (quals & TYPE_QUAL_RESTRICT)
627 pp_string (buffer, " restrict");
628
629 if (TYPE_REF_CAN_ALIAS_ALL (node))
630 pp_string (buffer, " {ref-all}");
631 }
632 break;
633
634 case OFFSET_TYPE:
635 NIY;
636 break;
637
638 case METHOD_TYPE:
639 dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
640 pp_string (buffer, "::");
641 break;
642
643 case TARGET_MEM_REF:
644 {
645 const char *sep = "";
646 tree tmp;
647
648 pp_string (buffer, "MEM[");
649
650 tmp = TMR_SYMBOL (node);
651 if (tmp)
652 {
653 pp_string (buffer, sep);
654 sep = ", ";
655 pp_string (buffer, "symbol: ");
656 dump_generic_node (buffer, tmp, spc, flags, false);
657 }
658 tmp = TMR_BASE (node);
659 if (tmp)
660 {
661 pp_string (buffer, sep);
662 sep = ", ";
663 pp_string (buffer, "base: ");
664 dump_generic_node (buffer, tmp, spc, flags, false);
665 }
666 tmp = TMR_INDEX (node);
667 if (tmp)
668 {
669 pp_string (buffer, sep);
670 sep = ", ";
671 pp_string (buffer, "index: ");
672 dump_generic_node (buffer, tmp, spc, flags, false);
673 }
674 tmp = TMR_STEP (node);
675 if (tmp)
676 {
677 pp_string (buffer, sep);
678 sep = ", ";
679 pp_string (buffer, "step: ");
680 dump_generic_node (buffer, tmp, spc, flags, false);
681 }
682 tmp = TMR_OFFSET (node);
683 if (tmp)
684 {
685 pp_string (buffer, sep);
686 sep = ", ";
687 pp_string (buffer, "offset: ");
688 dump_generic_node (buffer, tmp, spc, flags, false);
689 }
690 pp_string (buffer, "]");
691 if (flags & TDF_DETAILS)
692 {
693 pp_string (buffer, "{");
694 dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,
695 false);
696 pp_string (buffer, "}");
697 }
698 }
699 break;
700
701 case ARRAY_TYPE:
702 {
703 tree tmp;
704
705 /* Print the innermost component type. */
706 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
707 tmp = TREE_TYPE (tmp))
708 ;
709 dump_generic_node (buffer, tmp, spc, flags, false);
710
711 /* Print the dimensions. */
712 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
713 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
714 break;
715 }
716
717 case RECORD_TYPE:
718 case UNION_TYPE:
719 case QUAL_UNION_TYPE:
720 /* Print the name of the structure. */
721 if (TREE_CODE (node) == RECORD_TYPE)
722 pp_string (buffer, "struct ");
723 else if (TREE_CODE (node) == UNION_TYPE)
724 pp_string (buffer, "union ");
725
726 if (TYPE_NAME (node))
727 dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
728 else
729 print_struct_decl (buffer, node, spc, flags);
730 break;
731
732 case LANG_TYPE:
733 NIY;
734 break;
735
736 case INTEGER_CST:
737 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
738 {
739 /* In the case of a pointer, one may want to divide by the
740 size of the pointed-to type. Unfortunately, this not
741 straightforward. The C front-end maps expressions
742
743 (int *) 5
744 int *p; (p + 5)
745
746 in such a way that the two INTEGER_CST nodes for "5" have
747 different values but identical types. In the latter
748 case, the 5 is multiplied by sizeof (int) in c-common.c
749 (pointer_int_sum) to convert it to a byte address, and
750 yet the type of the node is left unchanged. Argh. What
751 is consistent though is that the number value corresponds
752 to bytes (UNITS) offset.
753
754 NB: Neither of the following divisors can be trivially
755 used to recover the original literal:
756
757 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
758 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
759 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
760 pp_string (buffer, "B"); /* pseudo-unit */
761 }
762 else if (! host_integerp (node, 0))
763 {
764 tree val = node;
765 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
766 HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);
767
768 if (tree_int_cst_sgn (val) < 0)
769 {
770 pp_character (buffer, '-');
771 high = ~high + !low;
772 low = -low;
773 }
774 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
775 systems? */
776 sprintf (pp_buffer (buffer)->digit_buffer,
777 HOST_WIDE_INT_PRINT_DOUBLE_HEX, high, low);
778 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
779 }
780 else
781 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
782 break;
783
784 case REAL_CST:
785 /* Code copied from print_node. */
786 {
787 REAL_VALUE_TYPE d;
788 if (TREE_OVERFLOW (node))
789 pp_string (buffer, " overflow");
790
791 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
792 d = TREE_REAL_CST (node);
793 if (REAL_VALUE_ISINF (d))
794 pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
795 else if (REAL_VALUE_ISNAN (d))
796 pp_string (buffer, " Nan");
797 else
798 {
799 char string[100];
800 real_to_decimal (string, &d, sizeof (string), 0, 1);
801 pp_string (buffer, string);
802 }
803 #else
804 {
805 HOST_WIDE_INT i;
806 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
807 pp_string (buffer, "0x");
808 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
809 output_formatted_integer (buffer, "%02x", *p++);
810 }
811 #endif
812 break;
813 }
814
815 case FIXED_CST:
816 {
817 char string[100];
818 fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
819 pp_string (buffer, string);
820 break;
821 }
822
823 case COMPLEX_CST:
824 pp_string (buffer, "__complex__ (");
825 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
826 pp_string (buffer, ", ");
827 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
828 pp_string (buffer, ")");
829 break;
830
831 case STRING_CST:
832 pp_string (buffer, "\"");
833 pretty_print_string (buffer, TREE_STRING_POINTER (node));
834 pp_string (buffer, "\"");
835 break;
836
837 case VECTOR_CST:
838 {
839 tree elt;
840 pp_string (buffer, "{ ");
841 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
842 {
843 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
844 if (TREE_CHAIN (elt))
845 pp_string (buffer, ", ");
846 }
847 pp_string (buffer, " }");
848 }
849 break;
850
851 case FUNCTION_TYPE:
852 break;
853
854 case FUNCTION_DECL:
855 case CONST_DECL:
856 dump_decl_name (buffer, node, flags);
857 break;
858
859 case LABEL_DECL:
860 if (DECL_NAME (node))
861 dump_decl_name (buffer, node, flags);
862 else if (LABEL_DECL_UID (node) != -1)
863 pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
864 LABEL_DECL_UID (node));
865 else
866 pp_printf (buffer, "<D.%u>", DECL_UID (node));
867 break;
868
869 case TYPE_DECL:
870 if (DECL_IS_BUILTIN (node))
871 {
872 /* Don't print the declaration of built-in types. */
873 break;
874 }
875 if (DECL_NAME (node))
876 dump_decl_name (buffer, node, flags);
877 else
878 {
879 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
880 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
881 && TYPE_METHODS (TREE_TYPE (node)))
882 {
883 /* The type is a c++ class: all structures have at least
884 4 methods. */
885 pp_string (buffer, "class ");
886 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
887 }
888 else
889 {
890 pp_string (buffer,
891 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
892 ? "union" : "struct "));
893 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
894 }
895 }
896 break;
897
898 case SYMBOL_MEMORY_TAG:
899 case NAME_MEMORY_TAG:
900 case STRUCT_FIELD_TAG:
901 case VAR_DECL:
902 case PARM_DECL:
903 case FIELD_DECL:
904 case NAMESPACE_DECL:
905 case MEMORY_PARTITION_TAG:
906 dump_decl_name (buffer, node, flags);
907 break;
908
909 case RESULT_DECL:
910 pp_string (buffer, "<retval>");
911 break;
912
913 case COMPONENT_REF:
914 op0 = TREE_OPERAND (node, 0);
915 str = ".";
916 if (TREE_CODE (op0) == INDIRECT_REF)
917 {
918 op0 = TREE_OPERAND (op0, 0);
919 str = "->";
920 }
921 if (op_prio (op0) < op_prio (node))
922 pp_character (buffer, '(');
923 dump_generic_node (buffer, op0, spc, flags, false);
924 if (op_prio (op0) < op_prio (node))
925 pp_character (buffer, ')');
926 pp_string (buffer, str);
927 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
928
929 if (TREE_CODE (op0) != VALUE_HANDLE)
930 {
931 op0 = component_ref_field_offset (node);
932 if (op0 && TREE_CODE (op0) != INTEGER_CST)
933 {
934 pp_string (buffer, "{off: ");
935 dump_generic_node (buffer, op0, spc, flags, false);
936 pp_character (buffer, '}');
937 }
938 }
939 break;
940
941 case BIT_FIELD_REF:
942 pp_string (buffer, "BIT_FIELD_REF <");
943 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
944 pp_string (buffer, ", ");
945 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
946 pp_string (buffer, ", ");
947 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
948 pp_string (buffer, ">");
949 break;
950
951 case ARRAY_REF:
952 case ARRAY_RANGE_REF:
953 op0 = TREE_OPERAND (node, 0);
954 if (op_prio (op0) < op_prio (node))
955 pp_character (buffer, '(');
956 dump_generic_node (buffer, op0, spc, flags, false);
957 if (op_prio (op0) < op_prio (node))
958 pp_character (buffer, ')');
959 pp_character (buffer, '[');
960 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
961 if (TREE_CODE (node) == ARRAY_RANGE_REF)
962 pp_string (buffer, " ...");
963 pp_character (buffer, ']');
964
965 op0 = array_ref_low_bound (node);
966 op1 = array_ref_element_size (node);
967
968 if (!integer_zerop (op0)
969 || TREE_OPERAND (node, 2)
970 || TREE_OPERAND (node, 3))
971 {
972 pp_string (buffer, "{lb: ");
973 dump_generic_node (buffer, op0, spc, flags, false);
974 pp_string (buffer, " sz: ");
975 dump_generic_node (buffer, op1, spc, flags, false);
976 pp_character (buffer, '}');
977 }
978 break;
979
980 case CONSTRUCTOR:
981 {
982 unsigned HOST_WIDE_INT ix;
983 tree field, val;
984 bool is_struct_init = FALSE;
985 pp_character (buffer, '{');
986 if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
987 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
988 is_struct_init = TRUE;
989 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
990 {
991 if (field && is_struct_init)
992 {
993 pp_character (buffer, '.');
994 dump_generic_node (buffer, field, spc, flags, false);
995 pp_string (buffer, "=");
996 }
997 if (val && TREE_CODE (val) == ADDR_EXPR)
998 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
999 val = TREE_OPERAND (val, 0);
1000 if (val && TREE_CODE (val) == FUNCTION_DECL)
1001 dump_decl_name (buffer, val, flags);
1002 else
1003 dump_generic_node (buffer, val, spc, flags, false);
1004 if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
1005 {
1006 pp_character (buffer, ',');
1007 pp_space (buffer);
1008 }
1009 }
1010 pp_character (buffer, '}');
1011 }
1012 break;
1013
1014 case COMPOUND_EXPR:
1015 {
1016 tree *tp;
1017 if (flags & TDF_SLIM)
1018 {
1019 pp_string (buffer, "<COMPOUND_EXPR>");
1020 break;
1021 }
1022
1023 dump_generic_node (buffer, TREE_OPERAND (node, 0),
1024 spc, flags, !(flags & TDF_SLIM));
1025 if (flags & TDF_SLIM)
1026 newline_and_indent (buffer, spc);
1027 else
1028 {
1029 pp_character (buffer, ',');
1030 pp_space (buffer);
1031 }
1032
1033 for (tp = &TREE_OPERAND (node, 1);
1034 TREE_CODE (*tp) == COMPOUND_EXPR;
1035 tp = &TREE_OPERAND (*tp, 1))
1036 {
1037 dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
1038 spc, flags, !(flags & TDF_SLIM));
1039 if (flags & TDF_SLIM)
1040 newline_and_indent (buffer, spc);
1041 else
1042 {
1043 pp_character (buffer, ',');
1044 pp_space (buffer);
1045 }
1046 }
1047
1048 dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
1049 }
1050 break;
1051
1052 case STATEMENT_LIST:
1053 {
1054 tree_stmt_iterator si;
1055 bool first = true;
1056
1057 if (flags & TDF_SLIM)
1058 {
1059 pp_string (buffer, "<STATEMENT_LIST>");
1060 break;
1061 }
1062
1063 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1064 {
1065 if (!first)
1066 newline_and_indent (buffer, spc);
1067 else
1068 first = false;
1069 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
1070 }
1071 }
1072 break;
1073
1074 case MODIFY_EXPR:
1075 case GIMPLE_MODIFY_STMT:
1076 case INIT_EXPR:
1077 dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 0), spc, flags,
1078 false);
1079 pp_space (buffer);
1080 pp_character (buffer, '=');
1081 if (TREE_CODE (node) == GIMPLE_MODIFY_STMT
1082 && MOVE_NONTEMPORAL (node))
1083 pp_string (buffer, "{nt}");
1084 if (TREE_CODE (node) == GIMPLE_MODIFY_STMT)
1085 {
1086 stmt_ann_t ann;
1087 if ((ann = stmt_ann (node))
1088 && ann->has_volatile_ops)
1089 pp_string (buffer, "{v}");
1090 }
1091 pp_space (buffer);
1092 dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
1093 false);
1094 break;
1095
1096 case TARGET_EXPR:
1097 pp_string (buffer, "TARGET_EXPR <");
1098 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1099 pp_character (buffer, ',');
1100 pp_space (buffer);
1101 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
1102 pp_character (buffer, '>');
1103 break;
1104
1105 case DECL_EXPR:
1106 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1107 is_stmt = false;
1108 break;
1109
1110 case COND_EXPR:
1111 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1112 {
1113 pp_string (buffer, "if (");
1114 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1115 pp_character (buffer, ')');
1116 /* The lowered cond_exprs should always be printed in full. */
1117 if (COND_EXPR_THEN (node)
1118 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1119 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1120 && COND_EXPR_ELSE (node)
1121 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1122 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1123 {
1124 pp_space (buffer);
1125 dump_generic_node (buffer, COND_EXPR_THEN (node),
1126 0, flags, true);
1127 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1128 {
1129 pp_string (buffer, " else ");
1130 dump_generic_node (buffer, COND_EXPR_ELSE (node),
1131 0, flags, true);
1132 }
1133 }
1134 else if (!(flags & TDF_SLIM))
1135 {
1136 /* Output COND_EXPR_THEN. */
1137 if (COND_EXPR_THEN (node))
1138 {
1139 newline_and_indent (buffer, spc+2);
1140 pp_character (buffer, '{');
1141 newline_and_indent (buffer, spc+4);
1142 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1143 flags, true);
1144 newline_and_indent (buffer, spc+2);
1145 pp_character (buffer, '}');
1146 }
1147
1148 /* Output COND_EXPR_ELSE. */
1149 if (COND_EXPR_ELSE (node)
1150 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1151 {
1152 newline_and_indent (buffer, spc);
1153 pp_string (buffer, "else");
1154 newline_and_indent (buffer, spc+2);
1155 pp_character (buffer, '{');
1156 newline_and_indent (buffer, spc+4);
1157 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1158 flags, true);
1159 newline_and_indent (buffer, spc+2);
1160 pp_character (buffer, '}');
1161 }
1162 }
1163 is_expr = false;
1164 }
1165 else
1166 {
1167 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1168 pp_space (buffer);
1169 pp_character (buffer, '?');
1170 pp_space (buffer);
1171 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1172 pp_space (buffer);
1173 pp_character (buffer, ':');
1174 pp_space (buffer);
1175 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1176 }
1177 break;
1178
1179 case BIND_EXPR:
1180 pp_character (buffer, '{');
1181 if (!(flags & TDF_SLIM))
1182 {
1183 if (BIND_EXPR_VARS (node))
1184 {
1185 pp_newline (buffer);
1186
1187 for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
1188 {
1189 print_declaration (buffer, op0, spc+2, flags);
1190 pp_newline (buffer);
1191 }
1192 }
1193
1194 newline_and_indent (buffer, spc+2);
1195 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1196 newline_and_indent (buffer, spc);
1197 pp_character (buffer, '}');
1198 }
1199 is_expr = false;
1200 break;
1201
1202 case CALL_EXPR:
1203 print_call_name (buffer, node);
1204
1205 /* Print parameters. */
1206 pp_space (buffer);
1207 pp_character (buffer, '(');
1208 {
1209 tree arg;
1210 call_expr_arg_iterator iter;
1211 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
1212 {
1213 dump_generic_node (buffer, arg, spc, flags, false);
1214 if (more_call_expr_args_p (&iter))
1215 {
1216 pp_character (buffer, ',');
1217 pp_space (buffer);
1218 }
1219 }
1220 }
1221 pp_character (buffer, ')');
1222
1223 op1 = CALL_EXPR_STATIC_CHAIN (node);
1224 if (op1)
1225 {
1226 pp_string (buffer, " [static-chain: ");
1227 dump_generic_node (buffer, op1, spc, flags, false);
1228 pp_character (buffer, ']');
1229 }
1230
1231 if (CALL_EXPR_RETURN_SLOT_OPT (node))
1232 pp_string (buffer, " [return slot optimization]");
1233 if (CALL_EXPR_TAILCALL (node))
1234 pp_string (buffer, " [tail call]");
1235 break;
1236
1237 case WITH_CLEANUP_EXPR:
1238 NIY;
1239 break;
1240
1241 case CLEANUP_POINT_EXPR:
1242 pp_string (buffer, "<<cleanup_point ");
1243 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1244 pp_string (buffer, ">>");
1245 break;
1246
1247 case PLACEHOLDER_EXPR:
1248 pp_string (buffer, "<PLACEHOLDER_EXPR ");
1249 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1250 pp_character (buffer, '>');
1251 break;
1252
1253 /* Binary arithmetic and logic expressions. */
1254 case WIDEN_SUM_EXPR:
1255 case WIDEN_MULT_EXPR:
1256 case MULT_EXPR:
1257 case PLUS_EXPR:
1258 case POINTER_PLUS_EXPR:
1259 case MINUS_EXPR:
1260 case TRUNC_DIV_EXPR:
1261 case CEIL_DIV_EXPR:
1262 case FLOOR_DIV_EXPR:
1263 case ROUND_DIV_EXPR:
1264 case TRUNC_MOD_EXPR:
1265 case CEIL_MOD_EXPR:
1266 case FLOOR_MOD_EXPR:
1267 case ROUND_MOD_EXPR:
1268 case RDIV_EXPR:
1269 case EXACT_DIV_EXPR:
1270 case LSHIFT_EXPR:
1271 case RSHIFT_EXPR:
1272 case LROTATE_EXPR:
1273 case RROTATE_EXPR:
1274 case VEC_LSHIFT_EXPR:
1275 case VEC_RSHIFT_EXPR:
1276 case BIT_IOR_EXPR:
1277 case BIT_XOR_EXPR:
1278 case BIT_AND_EXPR:
1279 case TRUTH_ANDIF_EXPR:
1280 case TRUTH_ORIF_EXPR:
1281 case TRUTH_AND_EXPR:
1282 case TRUTH_OR_EXPR:
1283 case TRUTH_XOR_EXPR:
1284 case LT_EXPR:
1285 case LE_EXPR:
1286 case GT_EXPR:
1287 case GE_EXPR:
1288 case EQ_EXPR:
1289 case NE_EXPR:
1290 case UNLT_EXPR:
1291 case UNLE_EXPR:
1292 case UNGT_EXPR:
1293 case UNGE_EXPR:
1294 case UNEQ_EXPR:
1295 case LTGT_EXPR:
1296 case ORDERED_EXPR:
1297 case UNORDERED_EXPR:
1298 {
1299 const char *op = op_symbol (node);
1300 op0 = TREE_OPERAND (node, 0);
1301 op1 = TREE_OPERAND (node, 1);
1302
1303 /* When the operands are expressions with less priority,
1304 keep semantics of the tree representation. */
1305 if (op_prio (op0) <= op_prio (node))
1306 {
1307 pp_character (buffer, '(');
1308 dump_generic_node (buffer, op0, spc, flags, false);
1309 pp_character (buffer, ')');
1310 }
1311 else
1312 dump_generic_node (buffer, op0, spc, flags, false);
1313
1314 pp_space (buffer);
1315 pp_string (buffer, op);
1316 pp_space (buffer);
1317
1318 /* When the operands are expressions with less priority,
1319 keep semantics of the tree representation. */
1320 if (op_prio (op1) <= op_prio (node))
1321 {
1322 pp_character (buffer, '(');
1323 dump_generic_node (buffer, op1, spc, flags, false);
1324 pp_character (buffer, ')');
1325 }
1326 else
1327 dump_generic_node (buffer, op1, spc, flags, false);
1328 }
1329 break;
1330
1331 /* Unary arithmetic and logic expressions. */
1332 case NEGATE_EXPR:
1333 case BIT_NOT_EXPR:
1334 case TRUTH_NOT_EXPR:
1335 case ADDR_EXPR:
1336 case PREDECREMENT_EXPR:
1337 case PREINCREMENT_EXPR:
1338 case ALIGN_INDIRECT_REF:
1339 case MISALIGNED_INDIRECT_REF:
1340 case INDIRECT_REF:
1341 if (TREE_CODE (node) == ADDR_EXPR
1342 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1343 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1344 ; /* Do not output '&' for strings and function pointers. */
1345 else
1346 pp_string (buffer, op_symbol (node));
1347
1348 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1349 {
1350 pp_character (buffer, '(');
1351 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1352 pp_character (buffer, ')');
1353 }
1354 else
1355 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1356
1357 if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1358 {
1359 pp_string (buffer, "{misalignment: ");
1360 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1361 pp_character (buffer, '}');
1362 }
1363 break;
1364
1365 case POSTDECREMENT_EXPR:
1366 case POSTINCREMENT_EXPR:
1367 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1368 {
1369 pp_character (buffer, '(');
1370 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1371 pp_character (buffer, ')');
1372 }
1373 else
1374 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1375 pp_string (buffer, op_symbol (node));
1376 break;
1377
1378 case MIN_EXPR:
1379 pp_string (buffer, "MIN_EXPR <");
1380 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1381 pp_string (buffer, ", ");
1382 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1383 pp_character (buffer, '>');
1384 break;
1385
1386 case MAX_EXPR:
1387 pp_string (buffer, "MAX_EXPR <");
1388 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1389 pp_string (buffer, ", ");
1390 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1391 pp_character (buffer, '>');
1392 break;
1393
1394 case ABS_EXPR:
1395 pp_string (buffer, "ABS_EXPR <");
1396 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1397 pp_character (buffer, '>');
1398 break;
1399
1400 case RANGE_EXPR:
1401 NIY;
1402 break;
1403
1404 case FIXED_CONVERT_EXPR:
1405 case FIX_TRUNC_EXPR:
1406 case FLOAT_EXPR:
1407 case CONVERT_EXPR:
1408 case NOP_EXPR:
1409 type = TREE_TYPE (node);
1410 op0 = TREE_OPERAND (node, 0);
1411 if (type != TREE_TYPE (op0))
1412 {
1413 pp_character (buffer, '(');
1414 dump_generic_node (buffer, type, spc, flags, false);
1415 pp_string (buffer, ") ");
1416 }
1417 if (op_prio (op0) < op_prio (node))
1418 pp_character (buffer, '(');
1419 dump_generic_node (buffer, op0, spc, flags, false);
1420 if (op_prio (op0) < op_prio (node))
1421 pp_character (buffer, ')');
1422 break;
1423
1424 case VIEW_CONVERT_EXPR:
1425 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1426 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1427 pp_string (buffer, ">(");
1428 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1429 pp_character (buffer, ')');
1430 break;
1431
1432 case NON_LVALUE_EXPR:
1433 pp_string (buffer, "NON_LVALUE_EXPR <");
1434 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1435 pp_character (buffer, '>');
1436 break;
1437
1438 case SAVE_EXPR:
1439 pp_string (buffer, "SAVE_EXPR <");
1440 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1441 pp_character (buffer, '>');
1442 break;
1443
1444 case COMPLEX_EXPR:
1445 pp_string (buffer, "COMPLEX_EXPR <");
1446 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1447 pp_string (buffer, ", ");
1448 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1449 pp_string (buffer, ">");
1450 break;
1451
1452 case CONJ_EXPR:
1453 pp_string (buffer, "CONJ_EXPR <");
1454 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1455 pp_string (buffer, ">");
1456 break;
1457
1458 case REALPART_EXPR:
1459 pp_string (buffer, "REALPART_EXPR <");
1460 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1461 pp_string (buffer, ">");
1462 break;
1463
1464 case IMAGPART_EXPR:
1465 pp_string (buffer, "IMAGPART_EXPR <");
1466 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1467 pp_string (buffer, ">");
1468 break;
1469
1470 case VA_ARG_EXPR:
1471 pp_string (buffer, "VA_ARG_EXPR <");
1472 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1473 pp_string (buffer, ">");
1474 break;
1475
1476 case TRY_FINALLY_EXPR:
1477 case TRY_CATCH_EXPR:
1478 pp_string (buffer, "try");
1479 newline_and_indent (buffer, spc+2);
1480 pp_string (buffer, "{");
1481 newline_and_indent (buffer, spc+4);
1482 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1483 newline_and_indent (buffer, spc+2);
1484 pp_string (buffer, "}");
1485 newline_and_indent (buffer, spc);
1486 pp_string (buffer,
1487 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1488 newline_and_indent (buffer, spc+2);
1489 pp_string (buffer, "{");
1490 newline_and_indent (buffer, spc+4);
1491 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1492 newline_and_indent (buffer, spc+2);
1493 pp_string (buffer, "}");
1494 is_expr = false;
1495 break;
1496
1497 case CATCH_EXPR:
1498 pp_string (buffer, "catch (");
1499 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1500 pp_string (buffer, ")");
1501 newline_and_indent (buffer, spc+2);
1502 pp_string (buffer, "{");
1503 newline_and_indent (buffer, spc+4);
1504 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1505 newline_and_indent (buffer, spc+2);
1506 pp_string (buffer, "}");
1507 is_expr = false;
1508 break;
1509
1510 case EH_FILTER_EXPR:
1511 pp_string (buffer, "<<<eh_filter (");
1512 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1513 pp_string (buffer, ")>>>");
1514 newline_and_indent (buffer, spc+2);
1515 pp_string (buffer, "{");
1516 newline_and_indent (buffer, spc+4);
1517 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1518 newline_and_indent (buffer, spc+2);
1519 pp_string (buffer, "}");
1520 is_expr = false;
1521 break;
1522
1523 case CHANGE_DYNAMIC_TYPE_EXPR:
1524 pp_string (buffer, "<<<change_dynamic_type (");
1525 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_NEW_TYPE (node), spc + 2,
1526 flags, false);
1527 pp_string (buffer, ") ");
1528 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_LOCATION (node), spc + 2,
1529 flags, false);
1530 pp_string (buffer, ")>>>");
1531 is_expr = false;
1532 break;
1533
1534 case LABEL_EXPR:
1535 op0 = TREE_OPERAND (node, 0);
1536 /* If this is for break or continue, don't bother printing it. */
1537 if (DECL_NAME (op0))
1538 {
1539 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1540 if (strcmp (name, "break") == 0
1541 || strcmp (name, "continue") == 0)
1542 break;
1543 }
1544 dump_generic_node (buffer, op0, spc, flags, false);
1545 pp_character (buffer, ':');
1546 if (DECL_NONLOCAL (op0))
1547 pp_string (buffer, " [non-local]");
1548 break;
1549
1550 case EXC_PTR_EXPR:
1551 pp_string (buffer, "<<<exception object>>>");
1552 break;
1553
1554 case FILTER_EXPR:
1555 pp_string (buffer, "<<<filter object>>>");
1556 break;
1557
1558 case LOOP_EXPR:
1559 pp_string (buffer, "while (1)");
1560 if (!(flags & TDF_SLIM))
1561 {
1562 newline_and_indent (buffer, spc+2);
1563 pp_character (buffer, '{');
1564 newline_and_indent (buffer, spc+4);
1565 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1566 newline_and_indent (buffer, spc+2);
1567 pp_character (buffer, '}');
1568 }
1569 is_expr = false;
1570 break;
1571
1572 case RETURN_EXPR:
1573 pp_string (buffer, "return");
1574 op0 = TREE_OPERAND (node, 0);
1575 if (op0)
1576 {
1577 pp_space (buffer);
1578 if (TREE_CODE (op0) == MODIFY_EXPR
1579 || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
1580 dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
1581 spc, flags, false);
1582 else
1583 dump_generic_node (buffer, op0, spc, flags, false);
1584 }
1585 break;
1586
1587 case EXIT_EXPR:
1588 pp_string (buffer, "if (");
1589 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1590 pp_string (buffer, ") break");
1591 break;
1592
1593 case SWITCH_EXPR:
1594 pp_string (buffer, "switch (");
1595 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1596 pp_character (buffer, ')');
1597 if (!(flags & TDF_SLIM))
1598 {
1599 newline_and_indent (buffer, spc+2);
1600 pp_character (buffer, '{');
1601 if (SWITCH_BODY (node))
1602 {
1603 newline_and_indent (buffer, spc+4);
1604 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1605 true);
1606 }
1607 else
1608 {
1609 tree vec = SWITCH_LABELS (node);
1610 size_t i, n = TREE_VEC_LENGTH (vec);
1611 for (i = 0; i < n; ++i)
1612 {
1613 tree elt = TREE_VEC_ELT (vec, i);
1614 newline_and_indent (buffer, spc+4);
1615 if (elt)
1616 {
1617 dump_generic_node (buffer, elt, spc+4, flags, false);
1618 pp_string (buffer, " goto ");
1619 dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1620 flags, true);
1621 pp_semicolon (buffer);
1622 }
1623 else
1624 pp_string (buffer, "case ???: goto ???;");
1625 }
1626 }
1627 newline_and_indent (buffer, spc+2);
1628 pp_character (buffer, '}');
1629 }
1630 is_expr = false;
1631 break;
1632
1633 case GOTO_EXPR:
1634 op0 = GOTO_DESTINATION (node);
1635 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1636 {
1637 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1638 if (strcmp (name, "break") == 0
1639 || strcmp (name, "continue") == 0)
1640 {
1641 pp_string (buffer, name);
1642 break;
1643 }
1644 }
1645 pp_string (buffer, "goto ");
1646 dump_generic_node (buffer, op0, spc, flags, false);
1647 break;
1648
1649 case RESX_EXPR:
1650 pp_string (buffer, "resx ");
1651 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1652 break;
1653
1654 case ASM_EXPR:
1655 pp_string (buffer, "__asm__");
1656 if (ASM_VOLATILE_P (node))
1657 pp_string (buffer, " __volatile__");
1658 pp_character (buffer, '(');
1659 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1660 pp_character (buffer, ':');
1661 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1662 pp_character (buffer, ':');
1663 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1664 if (ASM_CLOBBERS (node))
1665 {
1666 pp_character (buffer, ':');
1667 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1668 }
1669 pp_string (buffer, ")");
1670 break;
1671
1672 case CASE_LABEL_EXPR:
1673 if (CASE_LOW (node) && CASE_HIGH (node))
1674 {
1675 pp_string (buffer, "case ");
1676 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1677 pp_string (buffer, " ... ");
1678 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1679 }
1680 else if (CASE_LOW (node))
1681 {
1682 pp_string (buffer, "case ");
1683 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1684 }
1685 else
1686 pp_string (buffer, "default ");
1687 pp_character (buffer, ':');
1688 break;
1689
1690 case OBJ_TYPE_REF:
1691 pp_string (buffer, "OBJ_TYPE_REF(");
1692 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1693 pp_character (buffer, ';');
1694 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1695 pp_character (buffer, '-');
1696 pp_character (buffer, '>');
1697 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1698 pp_character (buffer, ')');
1699 break;
1700
1701 case PHI_NODE:
1702 {
1703 int i;
1704
1705 dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1706 pp_string (buffer, " = PHI <");
1707 for (i = 0; i < PHI_NUM_ARGS (node); i++)
1708 {
1709 dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1710 pp_string (buffer, "(");
1711 pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1712 pp_string (buffer, ")");
1713 if (i < PHI_NUM_ARGS (node) - 1)
1714 pp_string (buffer, ", ");
1715 }
1716 pp_string (buffer, ">");
1717
1718 if (stmt_references_memory_p (node) && (flags & TDF_MEMSYMS))
1719 dump_symbols (buffer, STORED_SYMS (node), flags);
1720 }
1721 break;
1722
1723 case SSA_NAME:
1724 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1725 pp_string (buffer, "_");
1726 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1727 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1728 pp_string (buffer, "(ab)");
1729 else if (SSA_NAME_IS_DEFAULT_DEF (node))
1730 pp_string (buffer, "(D)");
1731 break;
1732
1733 case WITH_SIZE_EXPR:
1734 pp_string (buffer, "WITH_SIZE_EXPR <");
1735 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1736 pp_string (buffer, ", ");
1737 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1738 pp_string (buffer, ">");
1739 break;
1740
1741 case VALUE_HANDLE:
1742 pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1743 break;
1744
1745 case ASSERT_EXPR:
1746 pp_string (buffer, "ASSERT_EXPR <");
1747 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1748 pp_string (buffer, ", ");
1749 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1750 pp_string (buffer, ">");
1751 break;
1752
1753 case SCEV_KNOWN:
1754 pp_string (buffer, "scev_known");
1755 break;
1756
1757 case SCEV_NOT_KNOWN:
1758 pp_string (buffer, "scev_not_known");
1759 break;
1760
1761 case POLYNOMIAL_CHREC:
1762 pp_string (buffer, "{");
1763 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1764 pp_string (buffer, ", +, ");
1765 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1766 pp_string (buffer, "}_");
1767 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1768 is_stmt = false;
1769 break;
1770
1771 case REALIGN_LOAD_EXPR:
1772 pp_string (buffer, "REALIGN_LOAD <");
1773 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1774 pp_string (buffer, ", ");
1775 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1776 pp_string (buffer, ", ");
1777 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1778 pp_string (buffer, ">");
1779 break;
1780
1781 case VEC_COND_EXPR:
1782 pp_string (buffer, " VEC_COND_EXPR < ");
1783 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1784 pp_string (buffer, " , ");
1785 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1786 pp_string (buffer, " , ");
1787 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1788 pp_string (buffer, " > ");
1789 break;
1790
1791 case DOT_PROD_EXPR:
1792 pp_string (buffer, " DOT_PROD_EXPR < ");
1793 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1794 pp_string (buffer, ", ");
1795 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1796 pp_string (buffer, ", ");
1797 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1798 pp_string (buffer, " > ");
1799 break;
1800
1801 case OMP_PARALLEL:
1802 pp_string (buffer, "#pragma omp parallel");
1803 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
1804 if (OMP_PARALLEL_FN (node))
1805 {
1806 pp_string (buffer, " [child fn: ");
1807 dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);
1808
1809 pp_string (buffer, " (");
1810
1811 if (OMP_PARALLEL_DATA_ARG (node))
1812 dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,
1813 false);
1814 else
1815 pp_string (buffer, "???");
1816
1817 pp_string (buffer, ")]");
1818 }
1819
1820 dump_omp_body:
1821 if (!(flags & TDF_SLIM) && OMP_BODY (node))
1822 {
1823 newline_and_indent (buffer, spc + 2);
1824 pp_character (buffer, '{');
1825 newline_and_indent (buffer, spc + 4);
1826 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
1827 newline_and_indent (buffer, spc + 2);
1828 pp_character (buffer, '}');
1829 }
1830 is_expr = false;
1831 break;
1832
1833 case OMP_FOR:
1834 pp_string (buffer, "#pragma omp for");
1835 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
1836
1837 if (!(flags & TDF_SLIM))
1838 {
1839 if (OMP_FOR_PRE_BODY (node))
1840 {
1841 newline_and_indent (buffer, spc + 2);
1842 pp_character (buffer, '{');
1843 spc += 4;
1844 newline_and_indent (buffer, spc);
1845 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
1846 spc, flags, false);
1847 }
1848 newline_and_indent (buffer, spc);
1849 pp_string (buffer, "for (");
1850 dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);
1851 pp_string (buffer, "; ");
1852 dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);
1853 pp_string (buffer, "; ");
1854 dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);
1855 pp_string (buffer, ")");
1856 if (OMP_FOR_BODY (node))
1857 {
1858 newline_and_indent (buffer, spc + 2);
1859 pp_character (buffer, '{');
1860 newline_and_indent (buffer, spc + 4);
1861 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
1862 false);
1863 newline_and_indent (buffer, spc + 2);
1864 pp_character (buffer, '}');
1865 }
1866 if (OMP_FOR_PRE_BODY (node))
1867 {
1868 spc -= 4;
1869 newline_and_indent (buffer, spc + 2);
1870 pp_character (buffer, '}');
1871 }
1872 }
1873 is_expr = false;
1874 break;
1875
1876 case OMP_SECTIONS:
1877 pp_string (buffer, "#pragma omp sections");
1878 if (OMP_SECTIONS_CONTROL (node))
1879 {
1880 pp_string (buffer, " <");
1881 dump_generic_node (buffer, OMP_SECTIONS_CONTROL (node), spc,
1882 flags, false);
1883 pp_string (buffer, ">");
1884 }
1885 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
1886 goto dump_omp_body;
1887
1888 case OMP_SECTIONS_SWITCH:
1889 pp_string (buffer, "OMP_SECTIONS_SWITCH");
1890 is_expr = false;
1891 break;
1892
1893 case OMP_SECTION:
1894 pp_string (buffer, "#pragma omp section");
1895 goto dump_omp_body;
1896
1897 case OMP_MASTER:
1898 pp_string (buffer, "#pragma omp master");
1899 goto dump_omp_body;
1900
1901 case OMP_ORDERED:
1902 pp_string (buffer, "#pragma omp ordered");
1903 goto dump_omp_body;
1904
1905 case OMP_CRITICAL:
1906 pp_string (buffer, "#pragma omp critical");
1907 if (OMP_CRITICAL_NAME (node))
1908 {
1909 pp_space (buffer);
1910 pp_character (buffer, '(');
1911 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
1912 flags, false);
1913 pp_character (buffer, ')');
1914 }
1915 goto dump_omp_body;
1916
1917 case OMP_ATOMIC:
1918 pp_string (buffer, "#pragma omp atomic");
1919 newline_and_indent (buffer, spc + 2);
1920 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1921 pp_space (buffer);
1922 pp_character (buffer, '=');
1923 pp_space (buffer);
1924 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1925 break;
1926
1927 case OMP_SINGLE:
1928 pp_string (buffer, "#pragma omp single");
1929 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
1930 goto dump_omp_body;
1931
1932 case OMP_RETURN:
1933 pp_string (buffer, "OMP_RETURN");
1934 if (OMP_RETURN_NOWAIT (node))
1935 pp_string (buffer, " [nowait]");
1936 is_expr = false;
1937 break;
1938
1939 case OMP_CONTINUE:
1940 pp_string (buffer, "OMP_CONTINUE <");
1941 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1942 pp_string (buffer, " <- ");
1943 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1944 pp_string (buffer, ">");
1945 is_expr = false;
1946 break;
1947
1948 case OMP_CLAUSE:
1949 dump_omp_clause (buffer, node, spc, flags);
1950 is_expr = false;
1951 break;
1952
1953 case REDUC_MAX_EXPR:
1954 pp_string (buffer, " REDUC_MAX_EXPR < ");
1955 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1956 pp_string (buffer, " > ");
1957 break;
1958
1959 case REDUC_MIN_EXPR:
1960 pp_string (buffer, " REDUC_MIN_EXPR < ");
1961 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1962 pp_string (buffer, " > ");
1963 break;
1964
1965 case REDUC_PLUS_EXPR:
1966 pp_string (buffer, " REDUC_PLUS_EXPR < ");
1967 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1968 pp_string (buffer, " > ");
1969 break;
1970
1971 case VEC_WIDEN_MULT_HI_EXPR:
1972 pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
1973 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1974 pp_string (buffer, ", ");
1975 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1976 pp_string (buffer, " > ");
1977 break;
1978
1979 case VEC_WIDEN_MULT_LO_EXPR:
1980 pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
1981 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1982 pp_string (buffer, ", ");
1983 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1984 pp_string (buffer, " > ");
1985 break;
1986
1987 case VEC_UNPACK_HI_EXPR:
1988 pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
1989 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1990 pp_string (buffer, " > ");
1991 break;
1992
1993 case VEC_UNPACK_LO_EXPR:
1994 pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
1995 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1996 pp_string (buffer, " > ");
1997 break;
1998
1999 case VEC_UNPACK_FLOAT_HI_EXPR:
2000 pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2001 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2002 pp_string (buffer, " > ");
2003 break;
2004
2005 case VEC_UNPACK_FLOAT_LO_EXPR:
2006 pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2007 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2008 pp_string (buffer, " > ");
2009 break;
2010
2011 case VEC_PACK_TRUNC_EXPR:
2012 pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
2013 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2014 pp_string (buffer, ", ");
2015 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2016 pp_string (buffer, " > ");
2017 break;
2018
2019 case VEC_PACK_SAT_EXPR:
2020 pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
2021 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2022 pp_string (buffer, ", ");
2023 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2024 pp_string (buffer, " > ");
2025 break;
2026
2027 case VEC_PACK_FIX_TRUNC_EXPR:
2028 pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");
2029 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2030 pp_string (buffer, ", ");
2031 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2032 pp_string (buffer, " > ");
2033 break;
2034
2035 case BLOCK:
2036 {
2037 tree t;
2038 pp_string (buffer, "BLOCK");
2039
2040 if (BLOCK_ABSTRACT (node))
2041 pp_string (buffer, " [abstract]");
2042
2043 if (TREE_ASM_WRITTEN (node))
2044 pp_string (buffer, " [written]");
2045
2046 newline_and_indent (buffer, spc + 2);
2047
2048 if (BLOCK_SUPERCONTEXT (node))
2049 {
2050 pp_string (buffer, "SUPERCONTEXT: ");
2051 if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
2052 pp_printf (buffer, "BLOCK %p",
2053 (void *)BLOCK_SUPERCONTEXT (node));
2054 else
2055 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
2056 false);
2057 newline_and_indent (buffer, spc + 2);
2058 }
2059
2060 if (BLOCK_SUBBLOCKS (node))
2061 {
2062 pp_string (buffer, "SUBBLOCKS: ");
2063 for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
2064 pp_printf (buffer, "%p ", (void *)t);
2065 newline_and_indent (buffer, spc + 2);
2066 }
2067
2068 if (BLOCK_VARS (node))
2069 {
2070 pp_string (buffer, "VARS: ");
2071 for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
2072 {
2073 dump_generic_node (buffer, t, 0, flags, false);
2074 pp_string (buffer, " ");
2075 }
2076 newline_and_indent (buffer, spc + 2);
2077 }
2078
2079 if (BLOCK_ABSTRACT_ORIGIN (node))
2080 {
2081 pp_string (buffer, "ABSTRACT_ORIGIN: ");
2082 if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
2083 pp_printf (buffer, "BLOCK %p",
2084 (void *)BLOCK_ABSTRACT_ORIGIN (node));
2085 else
2086 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
2087 false);
2088 newline_and_indent (buffer, spc + 2);
2089 }
2090 }
2091 break;
2092
2093 case VEC_EXTRACT_EVEN_EXPR:
2094 pp_string (buffer, " VEC_EXTRACT_EVEN_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, " > ");
2099 break;
2100
2101 case VEC_EXTRACT_ODD_EXPR:
2102 pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
2103 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2104 pp_string (buffer, ", ");
2105 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2106 pp_string (buffer, " > ");
2107 break;
2108
2109 case VEC_INTERLEAVE_HIGH_EXPR:
2110 pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
2111 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2112 pp_string (buffer, ", ");
2113 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2114 pp_string (buffer, " > ");
2115 break;
2116
2117 case VEC_INTERLEAVE_LOW_EXPR:
2118 pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
2119 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2120 pp_string (buffer, ", ");
2121 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2122 pp_string (buffer, " > ");
2123 break;
2124
2125 default:
2126 NIY;
2127 }
2128
2129 if (is_stmt && is_expr)
2130 pp_semicolon (buffer);
2131
2132 /* If we're building a diagnostic, the formatted text will be written
2133 into BUFFER's stream by the caller; otherwise, write it now. */
2134 if (!(flags & TDF_DIAGNOSTIC))
2135 pp_write_text_to_stream (buffer);
2136
2137 return spc;
2138 }
2139
2140 /* Print the declaration of a variable. */
2141
2142 static void
2143 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2144 {
2145 INDENT (spc);
2146
2147 if (TREE_CODE (t) == TYPE_DECL)
2148 pp_string (buffer, "typedef ");
2149
2150 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2151 pp_string (buffer, "register ");
2152
2153 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2154 pp_string (buffer, "extern ");
2155 else if (TREE_STATIC (t))
2156 pp_string (buffer, "static ");
2157
2158 /* Print the type and name. */
2159 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2160 {
2161 tree tmp;
2162
2163 /* Print array's type. */
2164 tmp = TREE_TYPE (t);
2165 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2166 tmp = TREE_TYPE (tmp);
2167 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2168
2169 /* Print variable's name. */
2170 pp_space (buffer);
2171 dump_generic_node (buffer, t, spc, flags, false);
2172
2173 /* Print the dimensions. */
2174 tmp = TREE_TYPE (t);
2175 while (TREE_CODE (tmp) == ARRAY_TYPE)
2176 {
2177 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
2178 tmp = TREE_TYPE (tmp);
2179 }
2180 }
2181 else if (TREE_CODE (t) == FUNCTION_DECL)
2182 {
2183 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2184 pp_space (buffer);
2185 dump_decl_name (buffer, t, flags);
2186 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2187 }
2188 else
2189 {
2190 /* Print type declaration. */
2191 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2192
2193 /* Print variable's name. */
2194 pp_space (buffer);
2195 dump_generic_node (buffer, t, spc, flags, false);
2196 }
2197
2198 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2199 {
2200 pp_string (buffer, " __asm__ ");
2201 pp_character (buffer, '(');
2202 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2203 pp_character (buffer, ')');
2204 }
2205
2206 /* The initial value of a function serves to determine wether the function
2207 is declared or defined. So the following does not apply to function
2208 nodes. */
2209 if (TREE_CODE (t) != FUNCTION_DECL)
2210 {
2211 /* Print the initial value. */
2212 if (DECL_INITIAL (t))
2213 {
2214 pp_space (buffer);
2215 pp_character (buffer, '=');
2216 pp_space (buffer);
2217 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2218 }
2219 }
2220
2221 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2222 {
2223 pp_string (buffer, " [value-expr: ");
2224 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2225 pp_character (buffer, ']');
2226 }
2227
2228 pp_character (buffer, ';');
2229 }
2230
2231
2232 /* Prints a structure: name, fields, and methods.
2233 FIXME: Still incomplete. */
2234
2235 static void
2236 print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
2237 {
2238 /* Print the name of the structure. */
2239 if (TYPE_NAME (node))
2240 {
2241 INDENT (spc);
2242 if (TREE_CODE (node) == RECORD_TYPE)
2243 pp_string (buffer, "struct ");
2244 else if ((TREE_CODE (node) == UNION_TYPE
2245 || TREE_CODE (node) == QUAL_UNION_TYPE))
2246 pp_string (buffer, "union ");
2247
2248 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2249 }
2250
2251 /* Print the contents of the structure. */
2252 pp_newline (buffer);
2253 INDENT (spc);
2254 pp_character (buffer, '{');
2255 pp_newline (buffer);
2256
2257 /* Print the fields of the structure. */
2258 {
2259 tree tmp;
2260 tmp = TYPE_FIELDS (node);
2261 while (tmp)
2262 {
2263 /* Avoid to print recursively the structure. */
2264 /* FIXME : Not implemented correctly...,
2265 what about the case when we have a cycle in the contain graph? ...
2266 Maybe this could be solved by looking at the scope in which the
2267 structure was declared. */
2268 if (TREE_TYPE (tmp) != node
2269 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
2270 && TREE_TYPE (TREE_TYPE (tmp)) != node))
2271 {
2272 print_declaration (buffer, tmp, spc+2, flags);
2273 pp_newline (buffer);
2274 }
2275 tmp = TREE_CHAIN (tmp);
2276 }
2277 }
2278 INDENT (spc);
2279 pp_character (buffer, '}');
2280 }
2281
2282 /* Return the priority of the operator OP.
2283
2284 From lowest to highest precedence with either left-to-right (L-R)
2285 or right-to-left (R-L) associativity]:
2286
2287 1 [L-R] ,
2288 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2289 3 [R-L] ?:
2290 4 [L-R] ||
2291 5 [L-R] &&
2292 6 [L-R] |
2293 7 [L-R] ^
2294 8 [L-R] &
2295 9 [L-R] == !=
2296 10 [L-R] < <= > >=
2297 11 [L-R] << >>
2298 12 [L-R] + -
2299 13 [L-R] * / %
2300 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2301 15 [L-R] fn() [] -> .
2302
2303 unary +, - and * have higher precedence than the corresponding binary
2304 operators. */
2305
2306 static int
2307 op_prio (const_tree op)
2308 {
2309 if (op == NULL)
2310 return 9999;
2311
2312 switch (TREE_CODE (op))
2313 {
2314 case TREE_LIST:
2315 case COMPOUND_EXPR:
2316 case BIND_EXPR:
2317 return 1;
2318
2319 case MODIFY_EXPR:
2320 case GIMPLE_MODIFY_STMT:
2321 case INIT_EXPR:
2322 return 2;
2323
2324 case COND_EXPR:
2325 return 3;
2326
2327 case TRUTH_OR_EXPR:
2328 case TRUTH_ORIF_EXPR:
2329 return 4;
2330
2331 case TRUTH_AND_EXPR:
2332 case TRUTH_ANDIF_EXPR:
2333 return 5;
2334
2335 case BIT_IOR_EXPR:
2336 return 6;
2337
2338 case BIT_XOR_EXPR:
2339 case TRUTH_XOR_EXPR:
2340 return 7;
2341
2342 case BIT_AND_EXPR:
2343 return 8;
2344
2345 case EQ_EXPR:
2346 case NE_EXPR:
2347 return 9;
2348
2349 case UNLT_EXPR:
2350 case UNLE_EXPR:
2351 case UNGT_EXPR:
2352 case UNGE_EXPR:
2353 case UNEQ_EXPR:
2354 case LTGT_EXPR:
2355 case ORDERED_EXPR:
2356 case UNORDERED_EXPR:
2357 case LT_EXPR:
2358 case LE_EXPR:
2359 case GT_EXPR:
2360 case GE_EXPR:
2361 return 10;
2362
2363 case LSHIFT_EXPR:
2364 case RSHIFT_EXPR:
2365 case LROTATE_EXPR:
2366 case RROTATE_EXPR:
2367 return 11;
2368
2369 case WIDEN_SUM_EXPR:
2370 case PLUS_EXPR:
2371 case POINTER_PLUS_EXPR:
2372 case MINUS_EXPR:
2373 return 12;
2374
2375 case VEC_WIDEN_MULT_HI_EXPR:
2376 case VEC_WIDEN_MULT_LO_EXPR:
2377 case WIDEN_MULT_EXPR:
2378 case DOT_PROD_EXPR:
2379 case MULT_EXPR:
2380 case TRUNC_DIV_EXPR:
2381 case CEIL_DIV_EXPR:
2382 case FLOOR_DIV_EXPR:
2383 case ROUND_DIV_EXPR:
2384 case RDIV_EXPR:
2385 case EXACT_DIV_EXPR:
2386 case TRUNC_MOD_EXPR:
2387 case CEIL_MOD_EXPR:
2388 case FLOOR_MOD_EXPR:
2389 case ROUND_MOD_EXPR:
2390 return 13;
2391
2392 case TRUTH_NOT_EXPR:
2393 case BIT_NOT_EXPR:
2394 case POSTINCREMENT_EXPR:
2395 case POSTDECREMENT_EXPR:
2396 case PREINCREMENT_EXPR:
2397 case PREDECREMENT_EXPR:
2398 case NEGATE_EXPR:
2399 case ALIGN_INDIRECT_REF:
2400 case MISALIGNED_INDIRECT_REF:
2401 case INDIRECT_REF:
2402 case ADDR_EXPR:
2403 case FLOAT_EXPR:
2404 case NOP_EXPR:
2405 case CONVERT_EXPR:
2406 case FIX_TRUNC_EXPR:
2407 case TARGET_EXPR:
2408 return 14;
2409
2410 case CALL_EXPR:
2411 case ARRAY_REF:
2412 case ARRAY_RANGE_REF:
2413 case COMPONENT_REF:
2414 return 15;
2415
2416 /* Special expressions. */
2417 case MIN_EXPR:
2418 case MAX_EXPR:
2419 case ABS_EXPR:
2420 case REALPART_EXPR:
2421 case IMAGPART_EXPR:
2422 case REDUC_MAX_EXPR:
2423 case REDUC_MIN_EXPR:
2424 case REDUC_PLUS_EXPR:
2425 case VEC_LSHIFT_EXPR:
2426 case VEC_RSHIFT_EXPR:
2427 case VEC_UNPACK_HI_EXPR:
2428 case VEC_UNPACK_LO_EXPR:
2429 case VEC_UNPACK_FLOAT_HI_EXPR:
2430 case VEC_UNPACK_FLOAT_LO_EXPR:
2431 case VEC_PACK_TRUNC_EXPR:
2432 case VEC_PACK_SAT_EXPR:
2433 return 16;
2434
2435 case SAVE_EXPR:
2436 case NON_LVALUE_EXPR:
2437 return op_prio (TREE_OPERAND (op, 0));
2438
2439 default:
2440 /* Return an arbitrarily high precedence to avoid surrounding single
2441 VAR_DECLs in ()s. */
2442 return 9999;
2443 }
2444 }
2445
2446
2447 /* Return the symbol associated with operator CODE. */
2448
2449 const char *
2450 op_symbol_code (enum tree_code code)
2451 {
2452 switch (code)
2453 {
2454 case MODIFY_EXPR:
2455 case GIMPLE_MODIFY_STMT:
2456 return "=";
2457
2458 case TRUTH_OR_EXPR:
2459 case TRUTH_ORIF_EXPR:
2460 return "||";
2461
2462 case TRUTH_AND_EXPR:
2463 case TRUTH_ANDIF_EXPR:
2464 return "&&";
2465
2466 case BIT_IOR_EXPR:
2467 return "|";
2468
2469 case TRUTH_XOR_EXPR:
2470 case BIT_XOR_EXPR:
2471 return "^";
2472
2473 case ADDR_EXPR:
2474 case BIT_AND_EXPR:
2475 return "&";
2476
2477 case ORDERED_EXPR:
2478 return "ord";
2479 case UNORDERED_EXPR:
2480 return "unord";
2481
2482 case EQ_EXPR:
2483 return "==";
2484 case UNEQ_EXPR:
2485 return "u==";
2486
2487 case NE_EXPR:
2488 return "!=";
2489
2490 case LT_EXPR:
2491 return "<";
2492 case UNLT_EXPR:
2493 return "u<";
2494
2495 case LE_EXPR:
2496 return "<=";
2497 case UNLE_EXPR:
2498 return "u<=";
2499
2500 case GT_EXPR:
2501 return ">";
2502 case UNGT_EXPR:
2503 return "u>";
2504
2505 case GE_EXPR:
2506 return ">=";
2507 case UNGE_EXPR:
2508 return "u>=";
2509
2510 case LTGT_EXPR:
2511 return "<>";
2512
2513 case LSHIFT_EXPR:
2514 return "<<";
2515
2516 case RSHIFT_EXPR:
2517 return ">>";
2518
2519 case LROTATE_EXPR:
2520 return "r<<";
2521
2522 case RROTATE_EXPR:
2523 return "r>>";
2524
2525 case VEC_LSHIFT_EXPR:
2526 return "v<<";
2527
2528 case VEC_RSHIFT_EXPR:
2529 return "v>>";
2530
2531 case POINTER_PLUS_EXPR:
2532 return "+";
2533
2534 case PLUS_EXPR:
2535 return "+";
2536
2537 case REDUC_PLUS_EXPR:
2538 return "r+";
2539
2540 case WIDEN_SUM_EXPR:
2541 return "w+";
2542
2543 case WIDEN_MULT_EXPR:
2544 return "w*";
2545
2546 case NEGATE_EXPR:
2547 case MINUS_EXPR:
2548 return "-";
2549
2550 case BIT_NOT_EXPR:
2551 return "~";
2552
2553 case TRUTH_NOT_EXPR:
2554 return "!";
2555
2556 case MULT_EXPR:
2557 case INDIRECT_REF:
2558 return "*";
2559
2560 case ALIGN_INDIRECT_REF:
2561 return "A*";
2562
2563 case MISALIGNED_INDIRECT_REF:
2564 return "M*";
2565
2566 case TRUNC_DIV_EXPR:
2567 case RDIV_EXPR:
2568 return "/";
2569
2570 case CEIL_DIV_EXPR:
2571 return "/[cl]";
2572
2573 case FLOOR_DIV_EXPR:
2574 return "/[fl]";
2575
2576 case ROUND_DIV_EXPR:
2577 return "/[rd]";
2578
2579 case EXACT_DIV_EXPR:
2580 return "/[ex]";
2581
2582 case TRUNC_MOD_EXPR:
2583 return "%";
2584
2585 case CEIL_MOD_EXPR:
2586 return "%[cl]";
2587
2588 case FLOOR_MOD_EXPR:
2589 return "%[fl]";
2590
2591 case ROUND_MOD_EXPR:
2592 return "%[rd]";
2593
2594 case PREDECREMENT_EXPR:
2595 return " --";
2596
2597 case PREINCREMENT_EXPR:
2598 return " ++";
2599
2600 case POSTDECREMENT_EXPR:
2601 return "-- ";
2602
2603 case POSTINCREMENT_EXPR:
2604 return "++ ";
2605
2606 case MAX_EXPR:
2607 return "max";
2608
2609 case MIN_EXPR:
2610 return "min";
2611
2612 default:
2613 return "<<< ??? >>>";
2614 }
2615 }
2616
2617 /* Return the symbol associated with operator OP. */
2618
2619 static const char *
2620 op_symbol (tree op)
2621 {
2622 return op_symbol_code (TREE_CODE (op));
2623 }
2624
2625 /* Prints the name of a CALL_EXPR. */
2626
2627 static void
2628 print_call_name (pretty_printer *buffer, tree node)
2629 {
2630 tree op0;
2631
2632 gcc_assert (TREE_CODE (node) == CALL_EXPR);
2633
2634 op0 = CALL_EXPR_FN (node);
2635
2636 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2637 op0 = TREE_OPERAND (op0, 0);
2638
2639 switch (TREE_CODE (op0))
2640 {
2641 case VAR_DECL:
2642 case PARM_DECL:
2643 dump_function_name (buffer, op0);
2644 break;
2645
2646 case ADDR_EXPR:
2647 case INDIRECT_REF:
2648 case NOP_EXPR:
2649 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2650 break;
2651
2652 case COND_EXPR:
2653 pp_string (buffer, "(");
2654 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2655 pp_string (buffer, ") ? ");
2656 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
2657 pp_string (buffer, " : ");
2658 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
2659 break;
2660
2661 case COMPONENT_REF:
2662 /* The function is a pointer contained in a structure. */
2663 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
2664 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2665 dump_function_name (buffer, TREE_OPERAND (op0, 1));
2666 else
2667 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2668 /* else
2669 We can have several levels of structures and a function
2670 pointer inside. This is not implemented yet... */
2671 /* NIY;*/
2672 break;
2673
2674 case ARRAY_REF:
2675 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2676 dump_function_name (buffer, TREE_OPERAND (op0, 0));
2677 else
2678 dump_generic_node (buffer, op0, 0, 0, false);
2679 break;
2680
2681 case SSA_NAME:
2682 case OBJ_TYPE_REF:
2683 dump_generic_node (buffer, op0, 0, 0, false);
2684 break;
2685
2686 default:
2687 NIY;
2688 }
2689 }
2690
2691 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2692
2693 static void
2694 pretty_print_string (pretty_printer *buffer, const char *str)
2695 {
2696 if (str == NULL)
2697 return;
2698
2699 while (*str)
2700 {
2701 switch (str[0])
2702 {
2703 case '\b':
2704 pp_string (buffer, "\\b");
2705 break;
2706
2707 case '\f':
2708 pp_string (buffer, "\\f");
2709 break;
2710
2711 case '\n':
2712 pp_string (buffer, "\\n");
2713 break;
2714
2715 case '\r':
2716 pp_string (buffer, "\\r");
2717 break;
2718
2719 case '\t':
2720 pp_string (buffer, "\\t");
2721 break;
2722
2723 case '\v':
2724 pp_string (buffer, "\\v");
2725 break;
2726
2727 case '\\':
2728 pp_string (buffer, "\\\\");
2729 break;
2730
2731 case '\"':
2732 pp_string (buffer, "\\\"");
2733 break;
2734
2735 case '\'':
2736 pp_string (buffer, "\\'");
2737 break;
2738
2739 /* No need to handle \0; the loop terminates on \0. */
2740
2741 case '\1':
2742 pp_string (buffer, "\\1");
2743 break;
2744
2745 case '\2':
2746 pp_string (buffer, "\\2");
2747 break;
2748
2749 case '\3':
2750 pp_string (buffer, "\\3");
2751 break;
2752
2753 case '\4':
2754 pp_string (buffer, "\\4");
2755 break;
2756
2757 case '\5':
2758 pp_string (buffer, "\\5");
2759 break;
2760
2761 case '\6':
2762 pp_string (buffer, "\\6");
2763 break;
2764
2765 case '\7':
2766 pp_string (buffer, "\\7");
2767 break;
2768
2769 default:
2770 pp_character (buffer, str[0]);
2771 break;
2772 }
2773 str++;
2774 }
2775 }
2776
2777 static void
2778 maybe_init_pretty_print (FILE *file)
2779 {
2780 if (!initialized)
2781 {
2782 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2783 pp_needs_newline (&buffer) = true;
2784 initialized = 1;
2785 }
2786
2787 buffer.buffer->stream = file;
2788 }
2789
2790 static void
2791 newline_and_indent (pretty_printer *buffer, int spc)
2792 {
2793 pp_newline (buffer);
2794 INDENT (spc);
2795 }
2796
2797
2798 static void
2799 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2800 {
2801 struct voptype_d *vdefs;
2802 struct voptype_d *vuses;
2803 int i, n;
2804
2805 if (!ssa_operands_active () || !stmt_references_memory_p (stmt))
2806 return;
2807
2808 /* Even if the statement doesn't have virtual operators yet, it may
2809 contain symbol information (this happens before aliases have been
2810 computed). */
2811 if ((flags & TDF_MEMSYMS)
2812 && VUSE_OPS (stmt) == NULL
2813 && VDEF_OPS (stmt) == NULL)
2814 {
2815 if (LOADED_SYMS (stmt))
2816 {
2817 pp_string (buffer, "# LOADS: ");
2818 dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2819 newline_and_indent (buffer, spc);
2820 }
2821
2822 if (STORED_SYMS (stmt))
2823 {
2824 pp_string (buffer, "# STORES: ");
2825 dump_symbols (buffer, STORED_SYMS (stmt), flags);
2826 newline_and_indent (buffer, spc);
2827 }
2828
2829 return;
2830 }
2831
2832 vuses = VUSE_OPS (stmt);
2833 while (vuses)
2834 {
2835 pp_string (buffer, "# VUSE <");
2836
2837 n = VUSE_NUM (vuses);
2838 for (i = 0; i < n; i++)
2839 {
2840 dump_generic_node (buffer, VUSE_OP (vuses, i), spc + 2, flags, false);
2841 if (i < n - 1)
2842 pp_string (buffer, ", ");
2843 }
2844
2845 pp_string (buffer, ">");
2846
2847 if (flags & TDF_MEMSYMS)
2848 dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2849
2850 newline_and_indent (buffer, spc);
2851 vuses = vuses->next;
2852 }
2853
2854 vdefs = VDEF_OPS (stmt);
2855 while (vdefs)
2856 {
2857 pp_string (buffer, "# ");
2858 dump_generic_node (buffer, VDEF_RESULT (vdefs), spc + 2, flags, false);
2859 pp_string (buffer, " = VDEF <");
2860
2861 n = VDEF_NUM (vdefs);
2862 for (i = 0; i < n; i++)
2863 {
2864 dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, 0);
2865 if (i < n - 1)
2866 pp_string (buffer, ", ");
2867 }
2868
2869 pp_string (buffer, ">");
2870
2871 if ((flags & TDF_MEMSYMS) && vdefs->next == NULL)
2872 dump_symbols (buffer, STORED_SYMS (stmt), flags);
2873
2874 newline_and_indent (buffer, spc);
2875 vdefs = vdefs->next;
2876 }
2877 }
2878
2879
2880 /* Dumps basic block BB to FILE with details described by FLAGS and
2881 indented by INDENT spaces. */
2882
2883 void
2884 dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2885 {
2886 maybe_init_pretty_print (file);
2887 dump_generic_bb_buff (&buffer, bb, indent, flags);
2888 pp_flush (&buffer);
2889 }
2890
2891 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2892 spaces and details described by flags. */
2893
2894 static void
2895 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2896 {
2897 edge e;
2898 tree stmt;
2899 edge_iterator ei;
2900
2901 if (flags & TDF_BLOCKS)
2902 {
2903 INDENT (indent);
2904 pp_string (buffer, "# BLOCK ");
2905 pp_decimal_int (buffer, bb->index);
2906 if (bb->frequency)
2907 {
2908 pp_string (buffer, " freq:");
2909 pp_decimal_int (buffer, bb->frequency);
2910 }
2911 if (bb->count)
2912 {
2913 pp_string (buffer, " count:");
2914 pp_widest_integer (buffer, bb->count);
2915 }
2916
2917 if (flags & TDF_LINENO)
2918 {
2919 block_stmt_iterator bsi;
2920
2921 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2922 if (get_lineno (bsi_stmt (bsi)) != -1)
2923 {
2924 pp_string (buffer, ", starting at line ");
2925 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2926 break;
2927 }
2928 }
2929 newline_and_indent (buffer, indent);
2930
2931 pp_string (buffer, "# PRED:");
2932 pp_write_text_to_stream (buffer);
2933 FOR_EACH_EDGE (e, ei, bb->preds)
2934 if (flags & TDF_SLIM)
2935 {
2936 pp_string (buffer, " ");
2937 if (e->src == ENTRY_BLOCK_PTR)
2938 pp_string (buffer, "ENTRY");
2939 else
2940 pp_decimal_int (buffer, e->src->index);
2941 }
2942 else
2943 dump_edge_info (buffer->buffer->stream, e, 0);
2944 pp_newline (buffer);
2945 }
2946 else
2947 {
2948 stmt = first_stmt (bb);
2949 if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
2950 {
2951 INDENT (indent - 2);
2952 pp_string (buffer, "<bb ");
2953 pp_decimal_int (buffer, bb->index);
2954 pp_string (buffer, ">:");
2955 pp_newline (buffer);
2956 }
2957 }
2958 pp_write_text_to_stream (buffer);
2959 check_bb_profile (bb, buffer->buffer->stream);
2960 }
2961
2962 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2963 spaces. */
2964
2965 static void
2966 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
2967 {
2968 edge e;
2969 edge_iterator ei;
2970
2971 INDENT (indent);
2972 pp_string (buffer, "# SUCC:");
2973 pp_write_text_to_stream (buffer);
2974 FOR_EACH_EDGE (e, ei, bb->succs)
2975 if (flags & TDF_SLIM)
2976 {
2977 pp_string (buffer, " ");
2978 if (e->dest == EXIT_BLOCK_PTR)
2979 pp_string (buffer, "EXIT");
2980 else
2981 pp_decimal_int (buffer, e->dest->index);
2982 }
2983 else
2984 dump_edge_info (buffer->buffer->stream, e, 1);
2985 pp_newline (buffer);
2986 }
2987
2988 /* Dump PHI nodes of basic block BB to BUFFER with details described
2989 by FLAGS and indented by INDENT spaces. */
2990
2991 static void
2992 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
2993 {
2994 tree phi = phi_nodes (bb);
2995 if (!phi)
2996 return;
2997
2998 for (; phi; phi = PHI_CHAIN (phi))
2999 {
3000 if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
3001 {
3002 INDENT (indent);
3003 pp_string (buffer, "# ");
3004 dump_generic_node (buffer, phi, indent, flags, false);
3005 pp_newline (buffer);
3006 }
3007 }
3008 }
3009
3010
3011 /* Dump jump to basic block BB that is represented implicitly in the cfg
3012 to BUFFER. */
3013
3014 static void
3015 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
3016 {
3017 tree stmt;
3018
3019 stmt = first_stmt (bb);
3020
3021 pp_string (buffer, "goto <bb ");
3022 pp_decimal_int (buffer, bb->index);
3023 pp_string (buffer, ">");
3024 if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
3025 {
3026 pp_string (buffer, " (");
3027 dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
3028 pp_string (buffer, ")");
3029 }
3030 pp_semicolon (buffer);
3031 }
3032
3033 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
3034 by INDENT spaces, with details given by FLAGS. */
3035
3036 static void
3037 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
3038 int flags)
3039 {
3040 edge e;
3041 edge_iterator ei;
3042 tree stmt;
3043
3044 stmt = last_stmt (bb);
3045 if (stmt && TREE_CODE (stmt) == COND_EXPR)
3046 {
3047 edge true_edge, false_edge;
3048
3049 /* When we are emitting the code or changing CFG, it is possible that
3050 the edges are not yet created. When we are using debug_bb in such
3051 a situation, we do not want it to crash. */
3052 if (EDGE_COUNT (bb->succs) != 2)
3053 return;
3054 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
3055
3056 INDENT (indent + 2);
3057 pp_cfg_jump (buffer, true_edge->dest);
3058 newline_and_indent (buffer, indent);
3059 pp_string (buffer, "else");
3060 newline_and_indent (buffer, indent + 2);
3061 pp_cfg_jump (buffer, false_edge->dest);
3062 pp_newline (buffer);
3063 return;
3064 }
3065
3066 /* If there is a fallthru edge, we may need to add an artificial goto to the
3067 dump. */
3068 FOR_EACH_EDGE (e, ei, bb->succs)
3069 if (e->flags & EDGE_FALLTHRU)
3070 break;
3071 if (e && e->dest != bb->next_bb)
3072 {
3073 INDENT (indent);
3074
3075 if ((flags & TDF_LINENO)
3076 #ifdef USE_MAPPED_LOCATION
3077 && e->goto_locus != UNKNOWN_LOCATION
3078 #else
3079 && e->goto_locus
3080 #endif
3081 )
3082 {
3083 expanded_location goto_xloc;
3084 #ifdef USE_MAPPED_LOCATION
3085 goto_xloc = expand_location (e->goto_locus);
3086 #else
3087 goto_xloc = *e->goto_locus;
3088 #endif
3089 pp_character (buffer, '[');
3090 if (goto_xloc.file)
3091 {
3092 pp_string (buffer, goto_xloc.file);
3093 pp_string (buffer, " : ");
3094 }
3095 pp_decimal_int (buffer, goto_xloc.line);
3096 pp_string (buffer, "] ");
3097 }
3098
3099 pp_cfg_jump (buffer, e->dest);
3100 pp_newline (buffer);
3101 }
3102 }
3103
3104 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
3105 indented by INDENT spaces. */
3106
3107 static void
3108 dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
3109 int indent, int flags)
3110 {
3111 block_stmt_iterator bsi;
3112 tree stmt;
3113 int label_indent = indent - 2;
3114
3115 if (label_indent < 0)
3116 label_indent = 0;
3117
3118 dump_bb_header (buffer, bb, indent, flags);
3119
3120 dump_phi_nodes (buffer, bb, indent, flags);
3121
3122 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
3123 {
3124 int curr_indent;
3125
3126 stmt = bsi_stmt (bsi);
3127
3128 curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
3129
3130 INDENT (curr_indent);
3131 dump_generic_node (buffer, stmt, curr_indent, flags, true);
3132 pp_newline (buffer);
3133 dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
3134 }
3135
3136 dump_implicit_edges (buffer, bb, indent, flags);
3137
3138 if (flags & TDF_BLOCKS)
3139 dump_bb_end (buffer, bb, indent, flags);
3140 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org