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