?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PR/30079
[official-gcc.git] / gcc / tree-pretty-print.c
blob2c9a8c8a2cba0d7adb38a2d1a281eb5196e8ecef
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) || GIMPLE_STMT_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 GIMPLE_MODIFY_STMT:
1028 case INIT_EXPR:
1029 dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 0), spc, flags,
1030 false);
1031 pp_space (buffer);
1032 pp_character (buffer, '=');
1033 pp_space (buffer);
1034 dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
1035 false);
1036 break;
1037
1038 case TARGET_EXPR:
1039 pp_string (buffer, "TARGET_EXPR <");
1040 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1041 pp_character (buffer, ',');
1042 pp_space (buffer);
1043 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
1044 pp_character (buffer, '>');
1045 break;
1046
1047 case DECL_EXPR:
1048 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1049 is_stmt = false;
1050 break;
1051
1052 case COND_EXPR:
1053 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1054 {
1055 pp_string (buffer, "if (");
1056 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1057 pp_character (buffer, ')');
1058 /* The lowered cond_exprs should always be printed in full. */
1059 if (COND_EXPR_THEN (node)
1060 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1061 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1062 && COND_EXPR_ELSE (node)
1063 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1064 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1065 {
1066 pp_space (buffer);
1067 dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);
1068 pp_string (buffer, " else ");
1069 dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true);
1070 }
1071 else if (!(flags & TDF_SLIM))
1072 {
1073 /* Output COND_EXPR_THEN. */
1074 if (COND_EXPR_THEN (node))
1075 {
1076 newline_and_indent (buffer, spc+2);
1077 pp_character (buffer, '{');
1078 newline_and_indent (buffer, spc+4);
1079 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1080 flags, true);
1081 newline_and_indent (buffer, spc+2);
1082 pp_character (buffer, '}');
1083 }
1084
1085 /* Output COND_EXPR_ELSE. */
1086 if (COND_EXPR_ELSE (node))
1087 {
1088 newline_and_indent (buffer, spc);
1089 pp_string (buffer, "else");
1090 newline_and_indent (buffer, spc+2);
1091 pp_character (buffer, '{');
1092 newline_and_indent (buffer, spc+4);
1093 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1094 flags, true);
1095 newline_and_indent (buffer, spc+2);
1096 pp_character (buffer, '}');
1097 }
1098 }
1099 is_expr = false;
1100 }
1101 else
1102 {
1103 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1104 pp_space (buffer);
1105 pp_character (buffer, '?');
1106 pp_space (buffer);
1107 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1108 pp_space (buffer);
1109 pp_character (buffer, ':');
1110 pp_space (buffer);
1111 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1112 }
1113 break;
1114
1115 case BIND_EXPR:
1116 pp_character (buffer, '{');
1117 if (!(flags & TDF_SLIM))
1118 {
1119 if (BIND_EXPR_VARS (node))
1120 {
1121 pp_newline (buffer);
1122
1123 for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
1124 {
1125 print_declaration (buffer, op0, spc+2, flags);
1126 pp_newline (buffer);
1127 }
1128 }
1129
1130 newline_and_indent (buffer, spc+2);
1131 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1132 newline_and_indent (buffer, spc);
1133 pp_character (buffer, '}');
1134 }
1135 is_expr = false;
1136 break;
1137
1138 case CALL_EXPR:
1139 print_call_name (buffer, node);
1140
1141 /* Print parameters. */
1142 pp_space (buffer);
1143 pp_character (buffer, '(');
1144 op1 = TREE_OPERAND (node, 1);
1145 if (op1)
1146 dump_generic_node (buffer, op1, spc, flags, false);
1147 pp_character (buffer, ')');
1148
1149 op1 = TREE_OPERAND (node, 2);
1150 if (op1)
1151 {
1152 pp_string (buffer, " [static-chain: ");
1153 dump_generic_node (buffer, op1, spc, flags, false);
1154 pp_character (buffer, ']');
1155 }
1156
1157 if (CALL_EXPR_RETURN_SLOT_OPT (node))
1158 pp_string (buffer, " [return slot optimization]");
1159 if (CALL_EXPR_TAILCALL (node))
1160 pp_string (buffer, " [tail call]");
1161 break;
1162
1163 case WITH_CLEANUP_EXPR:
1164 NIY;
1165 break;
1166
1167 case CLEANUP_POINT_EXPR:
1168 pp_string (buffer, "<<cleanup_point ");
1169 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1170 pp_string (buffer, ">>");
1171 break;
1172
1173 case PLACEHOLDER_EXPR:
1174 pp_string (buffer, "<PLACEHOLDER_EXPR ");
1175 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1176 pp_character (buffer, '>');
1177 break;
1178
1179 /* Binary arithmetic and logic expressions. */
1180 case WIDEN_SUM_EXPR:
1181 case WIDEN_MULT_EXPR:
1182 case MULT_EXPR:
1183 case PLUS_EXPR:
1184 case MINUS_EXPR:
1185 case TRUNC_DIV_EXPR:
1186 case CEIL_DIV_EXPR:
1187 case FLOOR_DIV_EXPR:
1188 case ROUND_DIV_EXPR:
1189 case TRUNC_MOD_EXPR:
1190 case CEIL_MOD_EXPR:
1191 case FLOOR_MOD_EXPR:
1192 case ROUND_MOD_EXPR:
1193 case RDIV_EXPR:
1194 case EXACT_DIV_EXPR:
1195 case LSHIFT_EXPR:
1196 case RSHIFT_EXPR:
1197 case LROTATE_EXPR:
1198 case RROTATE_EXPR:
1199 case VEC_LSHIFT_EXPR:
1200 case VEC_RSHIFT_EXPR:
1201 case BIT_IOR_EXPR:
1202 case BIT_XOR_EXPR:
1203 case BIT_AND_EXPR:
1204 case TRUTH_ANDIF_EXPR:
1205 case TRUTH_ORIF_EXPR:
1206 case TRUTH_AND_EXPR:
1207 case TRUTH_OR_EXPR:
1208 case TRUTH_XOR_EXPR:
1209 case LT_EXPR:
1210 case LE_EXPR:
1211 case GT_EXPR:
1212 case GE_EXPR:
1213 case EQ_EXPR:
1214 case NE_EXPR:
1215 case UNLT_EXPR:
1216 case UNLE_EXPR:
1217 case UNGT_EXPR:
1218 case UNGE_EXPR:
1219 case UNEQ_EXPR:
1220 case LTGT_EXPR:
1221 case ORDERED_EXPR:
1222 case UNORDERED_EXPR:
1223 {
1224 const char *op = op_symbol (node);
1225 op0 = TREE_OPERAND (node, 0);
1226 op1 = TREE_OPERAND (node, 1);
1227
1228 /* When the operands are expressions with less priority,
1229 keep semantics of the tree representation. */
1230 if (op_prio (op0) < op_prio (node))
1231 {
1232 pp_character (buffer, '(');
1233 dump_generic_node (buffer, op0, spc, flags, false);
1234 pp_character (buffer, ')');
1235 }
1236 else
1237 dump_generic_node (buffer, op0, spc, flags, false);
1238
1239 pp_space (buffer);
1240 pp_string (buffer, op);
1241 pp_space (buffer);
1242
1243 /* When the operands are expressions with less priority,
1244 keep semantics of the tree representation. */
1245 if (op_prio (op1) < op_prio (node))
1246 {
1247 pp_character (buffer, '(');
1248 dump_generic_node (buffer, op1, spc, flags, false);
1249 pp_character (buffer, ')');
1250 }
1251 else
1252 dump_generic_node (buffer, op1, spc, flags, false);
1253 }
1254 break;
1255
1256 /* Unary arithmetic and logic expressions. */
1257 case NEGATE_EXPR:
1258 case BIT_NOT_EXPR:
1259 case TRUTH_NOT_EXPR:
1260 case ADDR_EXPR:
1261 case PREDECREMENT_EXPR:
1262 case PREINCREMENT_EXPR:
1263 case ALIGN_INDIRECT_REF:
1264 case MISALIGNED_INDIRECT_REF:
1265 case INDIRECT_REF:
1266 if (TREE_CODE (node) == ADDR_EXPR
1267 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1268 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1269 ; /* Do not output '&' for strings and function pointers. */
1270 else
1271 pp_string (buffer, op_symbol (node));
1272
1273 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1274 {
1275 pp_character (buffer, '(');
1276 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1277 pp_character (buffer, ')');
1278 }
1279 else
1280 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1281
1282 if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1283 {
1284 pp_string (buffer, "{misalignment: ");
1285 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1286 pp_character (buffer, '}');
1287 }
1288 break;
1289
1290 case POSTDECREMENT_EXPR:
1291 case POSTINCREMENT_EXPR:
1292 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1293 {
1294 pp_character (buffer, '(');
1295 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1296 pp_character (buffer, ')');
1297 }
1298 else
1299 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1300 pp_string (buffer, op_symbol (node));
1301 break;
1302
1303 case MIN_EXPR:
1304 pp_string (buffer, "MIN_EXPR <");
1305 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1306 pp_string (buffer, ", ");
1307 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1308 pp_character (buffer, '>');
1309 break;
1310
1311 case MAX_EXPR:
1312 pp_string (buffer, "MAX_EXPR <");
1313 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1314 pp_string (buffer, ", ");
1315 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1316 pp_character (buffer, '>');
1317 break;
1318
1319 case ABS_EXPR:
1320 pp_string (buffer, "ABS_EXPR <");
1321 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1322 pp_character (buffer, '>');
1323 break;
1324
1325 case RANGE_EXPR:
1326 NIY;
1327 break;
1328
1329 case FIX_TRUNC_EXPR:
1330 case FLOAT_EXPR:
1331 case CONVERT_EXPR:
1332 case NOP_EXPR:
1333 type = TREE_TYPE (node);
1334 op0 = TREE_OPERAND (node, 0);
1335 if (type != TREE_TYPE (op0))
1336 {
1337 pp_character (buffer, '(');
1338 dump_generic_node (buffer, type, spc, flags, false);
1339 pp_string (buffer, ") ");
1340 }
1341 if (op_prio (op0) < op_prio (node))
1342 pp_character (buffer, '(');
1343 dump_generic_node (buffer, op0, spc, flags, false);
1344 if (op_prio (op0) < op_prio (node))
1345 pp_character (buffer, ')');
1346 break;
1347
1348 case VIEW_CONVERT_EXPR:
1349 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1350 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1351 pp_string (buffer, ">(");
1352 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1353 pp_character (buffer, ')');
1354 break;
1355
1356 case NON_LVALUE_EXPR:
1357 pp_string (buffer, "NON_LVALUE_EXPR <");
1358 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1359 pp_character (buffer, '>');
1360 break;
1361
1362 case SAVE_EXPR:
1363 pp_string (buffer, "SAVE_EXPR <");
1364 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1365 pp_character (buffer, '>');
1366 break;
1367
1368 case COMPLEX_EXPR:
1369 pp_string (buffer, "COMPLEX_EXPR <");
1370 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1371 pp_string (buffer, ", ");
1372 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1373 pp_string (buffer, ">");
1374 break;
1375
1376 case CONJ_EXPR:
1377 pp_string (buffer, "CONJ_EXPR <");
1378 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1379 pp_string (buffer, ">");
1380 break;
1381
1382 case REALPART_EXPR:
1383 pp_string (buffer, "REALPART_EXPR <");
1384 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1385 pp_string (buffer, ">");
1386 break;
1387
1388 case IMAGPART_EXPR:
1389 pp_string (buffer, "IMAGPART_EXPR <");
1390 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1391 pp_string (buffer, ">");
1392 break;
1393
1394 case VA_ARG_EXPR:
1395 pp_string (buffer, "VA_ARG_EXPR <");
1396 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1397 pp_string (buffer, ">");
1398 break;
1399
1400 case TRY_FINALLY_EXPR:
1401 case TRY_CATCH_EXPR:
1402 pp_string (buffer, "try");
1403 newline_and_indent (buffer, spc+2);
1404 pp_string (buffer, "{");
1405 newline_and_indent (buffer, spc+4);
1406 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1407 newline_and_indent (buffer, spc+2);
1408 pp_string (buffer, "}");
1409 newline_and_indent (buffer, spc);
1410 pp_string (buffer,
1411 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1412 newline_and_indent (buffer, spc+2);
1413 pp_string (buffer, "{");
1414 newline_and_indent (buffer, spc+4);
1415 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1416 newline_and_indent (buffer, spc+2);
1417 pp_string (buffer, "}");
1418 is_expr = false;
1419 break;
1420
1421 case CATCH_EXPR:
1422 pp_string (buffer, "catch (");
1423 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1424 pp_string (buffer, ")");
1425 newline_and_indent (buffer, spc+2);
1426 pp_string (buffer, "{");
1427 newline_and_indent (buffer, spc+4);
1428 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1429 newline_and_indent (buffer, spc+2);
1430 pp_string (buffer, "}");
1431 is_expr = false;
1432 break;
1433
1434 case EH_FILTER_EXPR:
1435 pp_string (buffer, "<<<eh_filter (");
1436 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1437 pp_string (buffer, ")>>>");
1438 newline_and_indent (buffer, spc+2);
1439 pp_string (buffer, "{");
1440 newline_and_indent (buffer, spc+4);
1441 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1442 newline_and_indent (buffer, spc+2);
1443 pp_string (buffer, "}");
1444 is_expr = false;
1445 break;
1446
1447 case LABEL_EXPR:
1448 op0 = TREE_OPERAND (node, 0);
1449 /* If this is for break or continue, don't bother printing it. */
1450 if (DECL_NAME (op0))
1451 {
1452 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1453 if (strcmp (name, "break") == 0
1454 || strcmp (name, "continue") == 0)
1455 break;
1456 }
1457 dump_generic_node (buffer, op0, spc, flags, false);
1458 pp_character (buffer, ':');
1459 if (DECL_NONLOCAL (op0))
1460 pp_string (buffer, " [non-local]");
1461 break;
1462
1463 case EXC_PTR_EXPR:
1464 pp_string (buffer, "<<<exception object>>>");
1465 break;
1466
1467 case FILTER_EXPR:
1468 pp_string (buffer, "<<<filter object>>>");
1469 break;
1470
1471 case LOOP_EXPR:
1472 pp_string (buffer, "while (1)");
1473 if (!(flags & TDF_SLIM))
1474 {
1475 newline_and_indent (buffer, spc+2);
1476 pp_character (buffer, '{');
1477 newline_and_indent (buffer, spc+4);
1478 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1479 newline_and_indent (buffer, spc+2);
1480 pp_character (buffer, '}');
1481 }
1482 is_expr = false;
1483 break;
1484
1485 case RETURN_EXPR:
1486 pp_string (buffer, "return");
1487 op0 = TREE_OPERAND (node, 0);
1488 if (op0)
1489 {
1490 pp_space (buffer);
1491 if (TREE_CODE (op0) == MODIFY_EXPR
1492 || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
1493 dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
1494 spc, flags, false);
1495 else
1496 dump_generic_node (buffer, op0, spc, flags, false);
1497 }
1498 break;
1499
1500 case EXIT_EXPR:
1501 pp_string (buffer, "if (");
1502 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1503 pp_string (buffer, ") break");
1504 break;
1505
1506 case SWITCH_EXPR:
1507 pp_string (buffer, "switch (");
1508 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1509 pp_character (buffer, ')');
1510 if (!(flags & TDF_SLIM))
1511 {
1512 newline_and_indent (buffer, spc+2);
1513 pp_character (buffer, '{');
1514 if (SWITCH_BODY (node))
1515 {
1516 newline_and_indent (buffer, spc+4);
1517 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1518 true);
1519 }
1520 else
1521 {
1522 tree vec = SWITCH_LABELS (node);
1523 size_t i, n = TREE_VEC_LENGTH (vec);
1524 for (i = 0; i < n; ++i)
1525 {
1526 tree elt = TREE_VEC_ELT (vec, i);
1527 newline_and_indent (buffer, spc+4);
1528 if (elt)
1529 {
1530 dump_generic_node (buffer, elt, spc+4, flags, false);
1531 pp_string (buffer, " goto ");
1532 dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1533 flags, true);
1534 pp_semicolon (buffer);
1535 }
1536 else
1537 pp_string (buffer, "case ???: goto ???;");
1538 }
1539 }
1540 newline_and_indent (buffer, spc+2);
1541 pp_character (buffer, '}');
1542 }
1543 is_expr = false;
1544 break;
1545
1546 case GOTO_EXPR:
1547 op0 = GOTO_DESTINATION (node);
1548 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1549 {
1550 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1551 if (strcmp (name, "break") == 0
1552 || strcmp (name, "continue") == 0)
1553 {
1554 pp_string (buffer, name);
1555 break;
1556 }
1557 }
1558 pp_string (buffer, "goto ");
1559 dump_generic_node (buffer, op0, spc, flags, false);
1560 break;
1561
1562 case RESX_EXPR:
1563 pp_string (buffer, "resx ");
1564 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1565 break;
1566
1567 case ASM_EXPR:
1568 pp_string (buffer, "__asm__");
1569 if (ASM_VOLATILE_P (node))
1570 pp_string (buffer, " __volatile__");
1571 pp_character (buffer, '(');
1572 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1573 pp_character (buffer, ':');
1574 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1575 pp_character (buffer, ':');
1576 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1577 if (ASM_CLOBBERS (node))
1578 {
1579 pp_character (buffer, ':');
1580 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1581 }
1582 pp_string (buffer, ")");
1583 break;
1584
1585 case CASE_LABEL_EXPR:
1586 if (CASE_LOW (node) && CASE_HIGH (node))
1587 {
1588 pp_string (buffer, "case ");
1589 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1590 pp_string (buffer, " ... ");
1591 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1592 }
1593 else if (CASE_LOW (node))
1594 {
1595 pp_string (buffer, "case ");
1596 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1597 }
1598 else
1599 pp_string (buffer, "default ");
1600 pp_character (buffer, ':');
1601 break;
1602
1603 case OBJ_TYPE_REF:
1604 pp_string (buffer, "OBJ_TYPE_REF(");
1605 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1606 pp_character (buffer, ';');
1607 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1608 pp_character (buffer, '-');
1609 pp_character (buffer, '>');
1610 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1611 pp_character (buffer, ')');
1612 break;
1613
1614 case PHI_NODE:
1615 {
1616 int i;
1617
1618 dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1619 pp_string (buffer, " = PHI <");
1620 for (i = 0; i < PHI_NUM_ARGS (node); i++)
1621 {
1622 dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1623 pp_string (buffer, "(");
1624 pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1625 pp_string (buffer, ")");
1626 if (i < PHI_NUM_ARGS (node) - 1)
1627 pp_string (buffer, ", ");
1628 }
1629 pp_string (buffer, ">;");
1630 }
1631 break;
1632
1633 case SSA_NAME:
1634 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1635 pp_string (buffer, "_");
1636 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1637 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1638 pp_string (buffer, "(ab)");
1639 break;
1640
1641 case WITH_SIZE_EXPR:
1642 pp_string (buffer, "WITH_SIZE_EXPR <");
1643 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1644 pp_string (buffer, ", ");
1645 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1646 pp_string (buffer, ">");
1647 break;
1648
1649 case VALUE_HANDLE:
1650 pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1651 break;
1652
1653 case ASSERT_EXPR:
1654 pp_string (buffer, "ASSERT_EXPR <");
1655 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1656 pp_string (buffer, ", ");
1657 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1658 pp_string (buffer, ">");
1659 break;
1660
1661 case SCEV_KNOWN:
1662 pp_string (buffer, "scev_known");
1663 break;
1664
1665 case SCEV_NOT_KNOWN:
1666 pp_string (buffer, "scev_not_known");
1667 break;
1668
1669 case POLYNOMIAL_CHREC:
1670 pp_string (buffer, "{");
1671 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1672 pp_string (buffer, ", +, ");
1673 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1674 pp_string (buffer, "}_");
1675 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1676 is_stmt = false;
1677 break;
1678
1679 case REALIGN_LOAD_EXPR:
1680 pp_string (buffer, "REALIGN_LOAD <");
1681 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1682 pp_string (buffer, ", ");
1683 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1684 pp_string (buffer, ", ");
1685 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1686 pp_string (buffer, ">");
1687 break;
1688
1689 case VEC_COND_EXPR:
1690 pp_string (buffer, " VEC_COND_EXPR < ");
1691 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1692 pp_string (buffer, " , ");
1693 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1694 pp_string (buffer, " , ");
1695 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1696 pp_string (buffer, " > ");
1697 break;
1698
1699 case DOT_PROD_EXPR:
1700 pp_string (buffer, " DOT_PROD_EXPR < ");
1701 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1702 pp_string (buffer, ", ");
1703 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1704 pp_string (buffer, ", ");
1705 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1706 pp_string (buffer, " > ");
1707 break;
1708
1709 case OMP_PARALLEL:
1710 pp_string (buffer, "#pragma omp parallel");
1711 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
1712 if (OMP_PARALLEL_FN (node))
1713 {
1714 pp_string (buffer, " [child fn: ");
1715 dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);
1716
1717 pp_string (buffer, " (");
1718
1719 if (OMP_PARALLEL_DATA_ARG (node))
1720 dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,
1721 false);
1722 else
1723 pp_string (buffer, "???");
1724
1725 pp_string (buffer, ")]");
1726 }
1727
1728 dump_omp_body:
1729 if (!(flags & TDF_SLIM) && OMP_BODY (node))
1730 {
1731 newline_and_indent (buffer, spc + 2);
1732 pp_character (buffer, '{');
1733 newline_and_indent (buffer, spc + 4);
1734 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
1735 newline_and_indent (buffer, spc + 2);
1736 pp_character (buffer, '}');
1737 }
1738 is_expr = false;
1739 break;
1740
1741 case OMP_FOR:
1742 pp_string (buffer, "#pragma omp for");
1743 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
1744
1745 if (!(flags & TDF_SLIM))
1746 {
1747 if (OMP_FOR_PRE_BODY (node))
1748 {
1749 newline_and_indent (buffer, spc + 2);
1750 pp_character (buffer, '{');
1751 spc += 4;
1752 newline_and_indent (buffer, spc);
1753 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
1754 spc, flags, false);
1755 }
1756 newline_and_indent (buffer, spc);
1757 pp_string (buffer, "for (");
1758 dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);
1759 pp_string (buffer, "; ");
1760 dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);
1761 pp_string (buffer, "; ");
1762 dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);
1763 pp_string (buffer, ")");
1764 if (OMP_FOR_BODY (node))
1765 {
1766 newline_and_indent (buffer, spc + 2);
1767 pp_character (buffer, '{');
1768 newline_and_indent (buffer, spc + 4);
1769 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
1770 false);
1771 newline_and_indent (buffer, spc + 2);
1772 pp_character (buffer, '}');
1773 }
1774 if (OMP_FOR_PRE_BODY (node))
1775 {
1776 spc -= 4;
1777 newline_and_indent (buffer, spc + 2);
1778 pp_character (buffer, '}');
1779 }
1780 }
1781 is_expr = false;
1782 break;
1783
1784 case OMP_SECTIONS:
1785 pp_string (buffer, "#pragma omp sections");
1786 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
1787 goto dump_omp_body;
1788
1789 case OMP_SECTION:
1790 pp_string (buffer, "#pragma omp section");
1791 goto dump_omp_body;
1792
1793 case OMP_MASTER:
1794 pp_string (buffer, "#pragma omp master");
1795 goto dump_omp_body;
1796
1797 case OMP_ORDERED:
1798 pp_string (buffer, "#pragma omp ordered");
1799 goto dump_omp_body;
1800
1801 case OMP_CRITICAL:
1802 pp_string (buffer, "#pragma omp critical");
1803 if (OMP_CRITICAL_NAME (node))
1804 {
1805 pp_space (buffer);
1806 pp_character (buffer, '(');
1807 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
1808 flags, false);
1809 pp_character (buffer, ')');
1810 }
1811 goto dump_omp_body;
1812
1813 case OMP_ATOMIC:
1814 pp_string (buffer, "#pragma omp atomic");
1815 newline_and_indent (buffer, spc + 2);
1816 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1817 pp_space (buffer);
1818 pp_character (buffer, '=');
1819 pp_space (buffer);
1820 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1821 break;
1822
1823 case OMP_SINGLE:
1824 pp_string (buffer, "#pragma omp single");
1825 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
1826 goto dump_omp_body;
1827
1828 case OMP_RETURN:
1829 pp_string (buffer, "OMP_RETURN");
1830 if (OMP_RETURN_NOWAIT (node))
1831 pp_string (buffer, " [nowait]");
1832 is_expr = false;
1833 break;
1834
1835 case OMP_CONTINUE:
1836 pp_string (buffer, "OMP_CONTINUE");
1837 is_expr = false;
1838 break;
1839
1840 case OMP_CLAUSE:
1841 dump_omp_clause (buffer, node, spc, flags);
1842 is_expr = false;
1843 break;
1844
1845 case REDUC_MAX_EXPR:
1846 pp_string (buffer, " REDUC_MAX_EXPR < ");
1847 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1848 pp_string (buffer, " > ");
1849 break;
1850
1851 case REDUC_MIN_EXPR:
1852 pp_string (buffer, " REDUC_MIN_EXPR < ");
1853 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1854 pp_string (buffer, " > ");
1855 break;
1856
1857 case REDUC_PLUS_EXPR:
1858 pp_string (buffer, " REDUC_PLUS_EXPR < ");
1859 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1860 pp_string (buffer, " > ");
1861 break;
1862
1863 case VEC_WIDEN_MULT_HI_EXPR:
1864 pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
1865 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1866 pp_string (buffer, ", ");
1867 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1868 pp_string (buffer, " > ");
1869 break;
1870
1871 case VEC_WIDEN_MULT_LO_EXPR:
1872 pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
1873 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1874 pp_string (buffer, ", ");
1875 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1876 pp_string (buffer, " > ");
1877 break;
1878
1879 case VEC_UNPACK_HI_EXPR:
1880 pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
1881 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1882 pp_string (buffer, " > ");
1883 break;
1884
1885 case VEC_UNPACK_LO_EXPR:
1886 pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
1887 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1888 pp_string (buffer, " > ");
1889 break;
1890
1891 case VEC_PACK_MOD_EXPR:
1892 pp_string (buffer, " VEC_PACK_MOD_EXPR < ");
1893 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1894 pp_string (buffer, ", ");
1895 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1896 pp_string (buffer, " > ");
1897 break;
1898
1899 case VEC_PACK_SAT_EXPR:
1900 pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
1901 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1902 pp_string (buffer, ", ");
1903 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1904 pp_string (buffer, " > ");
1905 break;
1906
1907 case BLOCK:
1908 {
1909 tree t;
1910 pp_string (buffer, "BLOCK");
1911
1912 if (BLOCK_ABSTRACT (node))
1913 pp_string (buffer, " [abstract]");
1914
1915 if (TREE_ASM_WRITTEN (node))
1916 pp_string (buffer, " [written]");
1917
1918 newline_and_indent (buffer, spc + 2);
1919
1920 if (BLOCK_SUPERCONTEXT (node))
1921 {
1922 pp_string (buffer, "SUPERCONTEXT: ");
1923 if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
1924 pp_printf (buffer, "BLOCK %p",
1925 (void *)BLOCK_SUPERCONTEXT (node));
1926 else
1927 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
1928 false);
1929 newline_and_indent (buffer, spc + 2);
1930 }
1931
1932 if (BLOCK_SUBBLOCKS (node))
1933 {
1934 pp_string (buffer, "SUBBLOCKS: ");
1935 for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
1936 pp_printf (buffer, "%p ", (void *)t);
1937 newline_and_indent (buffer, spc + 2);
1938 }
1939
1940 if (BLOCK_VARS (node))
1941 {
1942 pp_string (buffer, "VARS: ");
1943 for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
1944 {
1945 dump_generic_node (buffer, t, 0, flags, false);
1946 pp_string (buffer, " ");
1947 }
1948 newline_and_indent (buffer, spc + 2);
1949 }
1950
1951 if (BLOCK_ABSTRACT_ORIGIN (node))
1952 {
1953 pp_string (buffer, "ABSTRACT_ORIGIN: ");
1954 if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
1955 pp_printf (buffer, "BLOCK %p",
1956 (void *)BLOCK_ABSTRACT_ORIGIN (node));
1957 else
1958 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
1959 false);
1960 newline_and_indent (buffer, spc + 2);
1961 }
1962 }
1963 break;
1964
1965 case VEC_EXTRACT_EVEN_EXPR:
1966 pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
1967 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1968 pp_string (buffer, ", ");
1969 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1970 pp_string (buffer, " > ");
1971 break;
1972
1973 case VEC_EXTRACT_ODD_EXPR:
1974 pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
1975 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1976 pp_string (buffer, ", ");
1977 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1978 pp_string (buffer, " > ");
1979 break;
1980
1981 case VEC_INTERLEAVE_HIGH_EXPR:
1982 pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
1983 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1984 pp_string (buffer, ", ");
1985 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1986 pp_string (buffer, " > ");
1987 break;
1988
1989 case VEC_INTERLEAVE_LOW_EXPR:
1990 pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
1991 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1992 pp_string (buffer, ", ");
1993 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1994 pp_string (buffer, " > ");
1995 break;
1996
1997 default:
1998 NIY;
1999 }
2000
2001 if (is_stmt && is_expr)
2002 pp_semicolon (buffer);
2003 pp_write_text_to_stream (buffer);
2004
2005 return spc;
2006 }
2007
2008 /* Print the declaration of a variable. */
2009
2010 static void
2011 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2012 {
2013 INDENT (spc);
2014
2015 if (TREE_CODE (t) == TYPE_DECL)
2016 pp_string (buffer, "typedef ");
2017
2018 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2019 pp_string (buffer, "register ");
2020
2021 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2022 pp_string (buffer, "extern ");
2023 else if (TREE_STATIC (t))
2024 pp_string (buffer, "static ");
2025
2026 /* Print the type and name. */
2027 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2028 {
2029 tree tmp;
2030
2031 /* Print array's type. */
2032 tmp = TREE_TYPE (t);
2033 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2034 tmp = TREE_TYPE (tmp);
2035 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2036
2037 /* Print variable's name. */
2038 pp_space (buffer);
2039 dump_generic_node (buffer, t, spc, flags, false);
2040
2041 /* Print the dimensions. */
2042 tmp = TREE_TYPE (t);
2043 while (TREE_CODE (tmp) == ARRAY_TYPE)
2044 {
2045 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
2046 tmp = TREE_TYPE (tmp);
2047 }
2048 }
2049 else if (TREE_CODE (t) == FUNCTION_DECL)
2050 {
2051 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2052 pp_space (buffer);
2053 dump_decl_name (buffer, t, flags);
2054 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2055 }
2056 else
2057 {
2058 /* Print type declaration. */
2059 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2060
2061 /* Print variable's name. */
2062 pp_space (buffer);
2063 dump_generic_node (buffer, t, spc, flags, false);
2064 }
2065
2066 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2067 {
2068 pp_string (buffer, " __asm__ ");
2069 pp_character (buffer, '(');
2070 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2071 pp_character (buffer, ')');
2072 }
2073
2074 /* The initial value of a function serves to determine wether the function
2075 is declared or defined. So the following does not apply to function
2076 nodes. */
2077 if (TREE_CODE (t) != FUNCTION_DECL)
2078 {
2079 /* Print the initial value. */
2080 if (DECL_INITIAL (t))
2081 {
2082 pp_space (buffer);
2083 pp_character (buffer, '=');
2084 pp_space (buffer);
2085 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2086 }
2087 }
2088
2089 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2090 {
2091 pp_string (buffer, " [value-expr: ");
2092 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2093 pp_character (buffer, ']');
2094 }
2095
2096 pp_character (buffer, ';');
2097 }
2098
2099
2100 /* Prints a structure: name, fields, and methods.
2101 FIXME: Still incomplete. */
2102
2103 static void
2104 print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
2105 {
2106 /* Print the name of the structure. */
2107 if (TYPE_NAME (node))
2108 {
2109 INDENT (spc);
2110 if (TREE_CODE (node) == RECORD_TYPE)
2111 pp_string (buffer, "struct ");
2112 else if ((TREE_CODE (node) == UNION_TYPE
2113 || TREE_CODE (node) == QUAL_UNION_TYPE))
2114 pp_string (buffer, "union ");
2115
2116 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2117 }
2118
2119 /* Print the contents of the structure. */
2120 pp_newline (buffer);
2121 INDENT (spc);
2122 pp_character (buffer, '{');
2123 pp_newline (buffer);
2124
2125 /* Print the fields of the structure. */
2126 {
2127 tree tmp;
2128 tmp = TYPE_FIELDS (node);
2129 while (tmp)
2130 {
2131 /* Avoid to print recursively the structure. */
2132 /* FIXME : Not implemented correctly...,
2133 what about the case when we have a cycle in the contain graph? ...
2134 Maybe this could be solved by looking at the scope in which the
2135 structure was declared. */
2136 if (TREE_TYPE (tmp) != node
2137 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
2138 && TREE_TYPE (TREE_TYPE (tmp)) != node))
2139 {
2140 print_declaration (buffer, tmp, spc+2, flags);
2141 pp_newline (buffer);
2142 }
2143 tmp = TREE_CHAIN (tmp);
2144 }
2145 }
2146 INDENT (spc);
2147 pp_character (buffer, '}');
2148 }
2149
2150 /* Return the priority of the operator OP.
2151
2152 From lowest to highest precedence with either left-to-right (L-R)
2153 or right-to-left (R-L) associativity]:
2154
2155 1 [L-R] ,
2156 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2157 3 [R-L] ?:
2158 4 [L-R] ||
2159 5 [L-R] &&
2160 6 [L-R] |
2161 7 [L-R] ^
2162 8 [L-R] &
2163 9 [L-R] == !=
2164 10 [L-R] < <= > >=
2165 11 [L-R] << >>
2166 12 [L-R] + -
2167 13 [L-R] * / %
2168 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2169 15 [L-R] fn() [] -> .
2170
2171 unary +, - and * have higher precedence than the corresponding binary
2172 operators. */
2173
2174 static int
2175 op_prio (tree op)
2176 {
2177 if (op == NULL)
2178 return 9999;
2179
2180 switch (TREE_CODE (op))
2181 {
2182 case TREE_LIST:
2183 case COMPOUND_EXPR:
2184 case BIND_EXPR:
2185 return 1;
2186
2187 case MODIFY_EXPR:
2188 case GIMPLE_MODIFY_STMT:
2189 case INIT_EXPR:
2190 return 2;
2191
2192 case COND_EXPR:
2193 return 3;
2194
2195 case TRUTH_OR_EXPR:
2196 case TRUTH_ORIF_EXPR:
2197 return 4;
2198
2199 case TRUTH_AND_EXPR:
2200 case TRUTH_ANDIF_EXPR:
2201 return 5;
2202
2203 case BIT_IOR_EXPR:
2204 return 6;
2205
2206 case BIT_XOR_EXPR:
2207 case TRUTH_XOR_EXPR:
2208 return 7;
2209
2210 case BIT_AND_EXPR:
2211 return 8;
2212
2213 case EQ_EXPR:
2214 case NE_EXPR:
2215 return 9;
2216
2217 case UNLT_EXPR:
2218 case UNLE_EXPR:
2219 case UNGT_EXPR:
2220 case UNGE_EXPR:
2221 case UNEQ_EXPR:
2222 case LTGT_EXPR:
2223 case ORDERED_EXPR:
2224 case UNORDERED_EXPR:
2225 case LT_EXPR:
2226 case LE_EXPR:
2227 case GT_EXPR:
2228 case GE_EXPR:
2229 return 10;
2230
2231 case LSHIFT_EXPR:
2232 case RSHIFT_EXPR:
2233 case LROTATE_EXPR:
2234 case RROTATE_EXPR:
2235 return 11;
2236
2237 case WIDEN_SUM_EXPR:
2238 case PLUS_EXPR:
2239 case MINUS_EXPR:
2240 return 12;
2241
2242 case VEC_WIDEN_MULT_HI_EXPR:
2243 case VEC_WIDEN_MULT_LO_EXPR:
2244 case WIDEN_MULT_EXPR:
2245 case DOT_PROD_EXPR:
2246 case MULT_EXPR:
2247 case TRUNC_DIV_EXPR:
2248 case CEIL_DIV_EXPR:
2249 case FLOOR_DIV_EXPR:
2250 case ROUND_DIV_EXPR:
2251 case RDIV_EXPR:
2252 case EXACT_DIV_EXPR:
2253 case TRUNC_MOD_EXPR:
2254 case CEIL_MOD_EXPR:
2255 case FLOOR_MOD_EXPR:
2256 case ROUND_MOD_EXPR:
2257 return 13;
2258
2259 case TRUTH_NOT_EXPR:
2260 case BIT_NOT_EXPR:
2261 case POSTINCREMENT_EXPR:
2262 case POSTDECREMENT_EXPR:
2263 case PREINCREMENT_EXPR:
2264 case PREDECREMENT_EXPR:
2265 case NEGATE_EXPR:
2266 case ALIGN_INDIRECT_REF:
2267 case MISALIGNED_INDIRECT_REF:
2268 case INDIRECT_REF:
2269 case ADDR_EXPR:
2270 case FLOAT_EXPR:
2271 case NOP_EXPR:
2272 case CONVERT_EXPR:
2273 case FIX_TRUNC_EXPR:
2274 case TARGET_EXPR:
2275 return 14;
2276
2277 case CALL_EXPR:
2278 case ARRAY_REF:
2279 case ARRAY_RANGE_REF:
2280 case COMPONENT_REF:
2281 return 15;
2282
2283 /* Special expressions. */
2284 case MIN_EXPR:
2285 case MAX_EXPR:
2286 case ABS_EXPR:
2287 case REALPART_EXPR:
2288 case IMAGPART_EXPR:
2289 case REDUC_MAX_EXPR:
2290 case REDUC_MIN_EXPR:
2291 case REDUC_PLUS_EXPR:
2292 case VEC_LSHIFT_EXPR:
2293 case VEC_RSHIFT_EXPR:
2294 case VEC_UNPACK_HI_EXPR:
2295 case VEC_UNPACK_LO_EXPR:
2296 case VEC_PACK_MOD_EXPR:
2297 case VEC_PACK_SAT_EXPR:
2298 return 16;
2299
2300 case SAVE_EXPR:
2301 case NON_LVALUE_EXPR:
2302 return op_prio (TREE_OPERAND (op, 0));
2303
2304 default:
2305 /* Return an arbitrarily high precedence to avoid surrounding single
2306 VAR_DECLs in ()s. */
2307 return 9999;
2308 }
2309 }
2310
2311
2312 /* Return the symbol associated with operator OP. */
2313
2314 static const char *
2315 op_symbol_1 (enum tree_code code)
2316 {
2317 switch (code)
2318 {
2319 case MODIFY_EXPR:
2320 case GIMPLE_MODIFY_STMT:
2321 return "=";
2322
2323 case TRUTH_OR_EXPR:
2324 case TRUTH_ORIF_EXPR:
2325 return "||";
2326
2327 case TRUTH_AND_EXPR:
2328 case TRUTH_ANDIF_EXPR:
2329 return "&&";
2330
2331 case BIT_IOR_EXPR:
2332 return "|";
2333
2334 case TRUTH_XOR_EXPR:
2335 case BIT_XOR_EXPR:
2336 return "^";
2337
2338 case ADDR_EXPR:
2339 case BIT_AND_EXPR:
2340 return "&";
2341
2342 case ORDERED_EXPR:
2343 return "ord";
2344 case UNORDERED_EXPR:
2345 return "unord";
2346
2347 case EQ_EXPR:
2348 return "==";
2349 case UNEQ_EXPR:
2350 return "u==";
2351
2352 case NE_EXPR:
2353 return "!=";
2354
2355 case LT_EXPR:
2356 return "<";
2357 case UNLT_EXPR:
2358 return "u<";
2359
2360 case LE_EXPR:
2361 return "<=";
2362 case UNLE_EXPR:
2363 return "u<=";
2364
2365 case GT_EXPR:
2366 return ">";
2367 case UNGT_EXPR:
2368 return "u>";
2369
2370 case GE_EXPR:
2371 return ">=";
2372 case UNGE_EXPR:
2373 return "u>=";
2374
2375 case LTGT_EXPR:
2376 return "<>";
2377
2378 case LSHIFT_EXPR:
2379 return "<<";
2380
2381 case RSHIFT_EXPR:
2382 return ">>";
2383
2384 case LROTATE_EXPR:
2385 return "r<<";
2386
2387 case RROTATE_EXPR:
2388 return "r>>";
2389
2390 case VEC_LSHIFT_EXPR:
2391 return "v<<";
2392
2393 case VEC_RSHIFT_EXPR:
2394 return "v>>";
2395
2396 case PLUS_EXPR:
2397 return "+";
2398
2399 case REDUC_PLUS_EXPR:
2400 return "r+";
2401
2402 case WIDEN_SUM_EXPR:
2403 return "w+";
2404
2405 case WIDEN_MULT_EXPR:
2406 return "w*";
2407
2408 case NEGATE_EXPR:
2409 case MINUS_EXPR:
2410 return "-";
2411
2412 case BIT_NOT_EXPR:
2413 return "~";
2414
2415 case TRUTH_NOT_EXPR:
2416 return "!";
2417
2418 case MULT_EXPR:
2419 case INDIRECT_REF:
2420 return "*";
2421
2422 case ALIGN_INDIRECT_REF:
2423 return "A*";
2424
2425 case MISALIGNED_INDIRECT_REF:
2426 return "M*";
2427
2428 case TRUNC_DIV_EXPR:
2429 case RDIV_EXPR:
2430 return "/";
2431
2432 case CEIL_DIV_EXPR:
2433 return "/[cl]";
2434
2435 case FLOOR_DIV_EXPR:
2436 return "/[fl]";
2437
2438 case ROUND_DIV_EXPR:
2439 return "/[rd]";
2440
2441 case EXACT_DIV_EXPR:
2442 return "/[ex]";
2443
2444 case TRUNC_MOD_EXPR:
2445 return "%";
2446
2447 case CEIL_MOD_EXPR:
2448 return "%[cl]";
2449
2450 case FLOOR_MOD_EXPR:
2451 return "%[fl]";
2452
2453 case ROUND_MOD_EXPR:
2454 return "%[rd]";
2455
2456 case PREDECREMENT_EXPR:
2457 return " --";
2458
2459 case PREINCREMENT_EXPR:
2460 return " ++";
2461
2462 case POSTDECREMENT_EXPR:
2463 return "-- ";
2464
2465 case POSTINCREMENT_EXPR:
2466 return "++ ";
2467
2468 case MAX_EXPR:
2469 return "max";
2470
2471 case MIN_EXPR:
2472 return "min";
2473
2474 default:
2475 return "<<< ??? >>>";
2476 }
2477 }
2478
2479 static const char *
2480 op_symbol (tree op)
2481 {
2482 return op_symbol_1 (TREE_CODE (op));
2483 }
2484
2485 /* Prints the name of a CALL_EXPR. */
2486
2487 static void
2488 print_call_name (pretty_printer *buffer, tree node)
2489 {
2490 tree op0;
2491
2492 gcc_assert (TREE_CODE (node) == CALL_EXPR);
2493
2494 op0 = TREE_OPERAND (node, 0);
2495
2496 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2497 op0 = TREE_OPERAND (op0, 0);
2498
2499 switch (TREE_CODE (op0))
2500 {
2501 case VAR_DECL:
2502 case PARM_DECL:
2503 dump_function_name (buffer, op0);
2504 break;
2505
2506 case ADDR_EXPR:
2507 case INDIRECT_REF:
2508 case NOP_EXPR:
2509 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2510 break;
2511
2512 case COND_EXPR:
2513 pp_string (buffer, "(");
2514 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2515 pp_string (buffer, ") ? ");
2516 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
2517 pp_string (buffer, " : ");
2518 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
2519 break;
2520
2521 case COMPONENT_REF:
2522 /* The function is a pointer contained in a structure. */
2523 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
2524 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2525 dump_function_name (buffer, TREE_OPERAND (op0, 1));
2526 else
2527 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2528 /* else
2529 We can have several levels of structures and a function
2530 pointer inside. This is not implemented yet... */
2531 /* NIY;*/
2532 break;
2533
2534 case ARRAY_REF:
2535 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2536 dump_function_name (buffer, TREE_OPERAND (op0, 0));
2537 else
2538 dump_generic_node (buffer, op0, 0, 0, false);
2539 break;
2540
2541 case SSA_NAME:
2542 case OBJ_TYPE_REF:
2543 dump_generic_node (buffer, op0, 0, 0, false);
2544 break;
2545
2546 default:
2547 NIY;
2548 }
2549 }
2550
2551 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2552
2553 static void
2554 pretty_print_string (pretty_printer *buffer, const char *str)
2555 {
2556 if (str == NULL)
2557 return;
2558
2559 while (*str)
2560 {
2561 switch (str[0])
2562 {
2563 case '\b':
2564 pp_string (buffer, "\\b");
2565 break;
2566
2567 case '\f':
2568 pp_string (buffer, "\\f");
2569 break;
2570
2571 case '\n':
2572 pp_string (buffer, "\\n");
2573 break;
2574
2575 case '\r':
2576 pp_string (buffer, "\\r");
2577 break;
2578
2579 case '\t':
2580 pp_string (buffer, "\\t");
2581 break;
2582
2583 case '\v':
2584 pp_string (buffer, "\\v");
2585 break;
2586
2587 case '\\':
2588 pp_string (buffer, "\\\\");
2589 break;
2590
2591 case '\"':
2592 pp_string (buffer, "\\\"");
2593 break;
2594
2595 case '\'':
2596 pp_string (buffer, "\\'");
2597 break;
2598
2599 /* No need to handle \0; the loop terminates on \0. */
2600
2601 case '\1':
2602 pp_string (buffer, "\\1");
2603 break;
2604
2605 case '\2':
2606 pp_string (buffer, "\\2");
2607 break;
2608
2609 case '\3':
2610 pp_string (buffer, "\\3");
2611 break;
2612
2613 case '\4':
2614 pp_string (buffer, "\\4");
2615 break;
2616
2617 case '\5':
2618 pp_string (buffer, "\\5");
2619 break;
2620
2621 case '\6':
2622 pp_string (buffer, "\\6");
2623 break;
2624
2625 case '\7':
2626 pp_string (buffer, "\\7");
2627 break;
2628
2629 default:
2630 pp_character (buffer, str[0]);
2631 break;
2632 }
2633 str++;
2634 }
2635 }
2636
2637 static void
2638 maybe_init_pretty_print (FILE *file)
2639 {
2640 if (!initialized)
2641 {
2642 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2643 pp_needs_newline (&buffer) = true;
2644 initialized = 1;
2645 }
2646
2647 buffer.buffer->stream = file;
2648 }
2649
2650 static void
2651 newline_and_indent (pretty_printer *buffer, int spc)
2652 {
2653 pp_newline (buffer);
2654 INDENT (spc);
2655 }
2656
2657 static void
2658 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2659 {
2660 tree use;
2661 use_operand_p use_p;
2662 def_operand_p def_p;
2663 use_operand_p kill_p;
2664 ssa_op_iter iter;
2665
2666 if (!ssa_operands_active ())
2667 return;
2668
2669 FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
2670 {
2671 pp_string (buffer, "# ");
2672 dump_generic_node (buffer, DEF_FROM_PTR (def_p),
2673 spc + 2, flags, false);
2674 pp_string (buffer, " = V_MAY_DEF <");
2675 dump_generic_node (buffer, USE_FROM_PTR (use_p),
2676 spc + 2, flags, false);
2677 pp_string (buffer, ">;");
2678 newline_and_indent (buffer, spc);
2679 }
2680
2681 FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter)
2682 {
2683 pp_string (buffer, "# ");
2684 dump_generic_node (buffer, DEF_FROM_PTR (def_p),
2685 spc + 2, flags, false);
2686 pp_string (buffer, " = V_MUST_DEF <");
2687 dump_generic_node (buffer, USE_FROM_PTR (kill_p),
2688 spc + 2, flags, false);
2689 pp_string (buffer, ">;");
2690 newline_and_indent (buffer, spc);
2691 }
2692
2693 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)
2694 {
2695 pp_string (buffer, "# VUSE <");
2696 dump_generic_node (buffer, use, spc + 2, flags, false);
2697 pp_string (buffer, ">;");
2698 newline_and_indent (buffer, spc);
2699 }
2700 }
2701
2702 /* Dumps basic block BB to FILE with details described by FLAGS and
2703 indented by INDENT spaces. */
2704
2705 void
2706 dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2707 {
2708 maybe_init_pretty_print (file);
2709 dump_generic_bb_buff (&buffer, bb, indent, flags);
2710 pp_flush (&buffer);
2711 }
2712
2713 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2714 spaces and details described by flags. */
2715
2716 static void
2717 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2718 {
2719 edge e;
2720 tree stmt;
2721 edge_iterator ei;
2722
2723 if (flags & TDF_BLOCKS)
2724 {
2725 INDENT (indent);
2726 pp_string (buffer, "# BLOCK ");
2727 pp_decimal_int (buffer, bb->index);
2728 if (bb->frequency)
2729 {
2730 pp_string (buffer, " freq:");
2731 pp_decimal_int (buffer, bb->frequency);
2732 }
2733 if (bb->count)
2734 {
2735 pp_string (buffer, " count:");
2736 pp_widest_integer (buffer, bb->count);
2737 }
2738
2739 if (flags & TDF_LINENO)
2740 {
2741 block_stmt_iterator bsi;
2742
2743 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2744 if (get_lineno (bsi_stmt (bsi)) != -1)
2745 {
2746 pp_string (buffer, ", starting at line ");
2747 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2748 break;
2749 }
2750 }
2751 newline_and_indent (buffer, indent);
2752
2753 pp_string (buffer, "# PRED:");
2754 pp_write_text_to_stream (buffer);
2755 FOR_EACH_EDGE (e, ei, bb->preds)
2756 if (flags & TDF_SLIM)
2757 {
2758 pp_string (buffer, " ");
2759 if (e->src == ENTRY_BLOCK_PTR)
2760 pp_string (buffer, "ENTRY");
2761 else
2762 pp_decimal_int (buffer, e->src->index);
2763 }
2764 else
2765 dump_edge_info (buffer->buffer->stream, e, 0);
2766 pp_newline (buffer);
2767 }
2768 else
2769 {
2770 stmt = first_stmt (bb);
2771 if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
2772 {
2773 INDENT (indent - 2);
2774 pp_string (buffer, "<bb ");
2775 pp_decimal_int (buffer, bb->index);
2776 pp_string (buffer, ">:");
2777 pp_newline (buffer);
2778 }
2779 }
2780 pp_write_text_to_stream (buffer);
2781 check_bb_profile (bb, buffer->buffer->stream);
2782 }
2783
2784 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2785 spaces. */
2786
2787 static void
2788 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
2789 {
2790 edge e;
2791 edge_iterator ei;
2792
2793 INDENT (indent);
2794 pp_string (buffer, "# SUCC:");
2795 pp_write_text_to_stream (buffer);
2796 FOR_EACH_EDGE (e, ei, bb->succs)
2797 if (flags & TDF_SLIM)
2798 {
2799 pp_string (buffer, " ");
2800 if (e->dest == EXIT_BLOCK_PTR)
2801 pp_string (buffer, "EXIT");
2802 else
2803 pp_decimal_int (buffer, e->dest->index);
2804 }
2805 else
2806 dump_edge_info (buffer->buffer->stream, e, 1);
2807 pp_newline (buffer);
2808 }
2809
2810 /* Dumps phi nodes of basic block BB to buffer BUFFER with details described by
2811 FLAGS indented by INDENT spaces. */
2812
2813 static void
2814 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
2815 {
2816 tree phi = phi_nodes (bb);
2817 if (!phi)
2818 return;
2819
2820 for (; phi; phi = PHI_CHAIN (phi))
2821 {
2822 if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
2823 {
2824 INDENT (indent);
2825 pp_string (buffer, "# ");
2826 dump_generic_node (buffer, phi, indent, flags, false);
2827 pp_newline (buffer);
2828 }
2829 }
2830 }
2831
2832 /* Dump jump to basic block BB that is represented implicitly in the cfg
2833 to BUFFER. */
2834
2835 static void
2836 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
2837 {
2838 tree stmt;
2839
2840 stmt = first_stmt (bb);
2841
2842 pp_string (buffer, "goto <bb ");
2843 pp_decimal_int (buffer, bb->index);
2844 pp_string (buffer, ">");
2845 if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
2846 {
2847 pp_string (buffer, " (");
2848 dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
2849 pp_string (buffer, ")");
2850 }
2851 pp_semicolon (buffer);
2852 }
2853
2854 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
2855 by INDENT spaces, with details given by FLAGS. */
2856
2857 static void
2858 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
2859 int flags)
2860 {
2861 edge e;
2862 edge_iterator ei;
2863
2864 /* If there is a fallthru edge, we may need to add an artificial goto to the
2865 dump. */
2866 FOR_EACH_EDGE (e, ei, bb->succs)
2867 if (e->flags & EDGE_FALLTHRU)
2868 break;
2869 if (e && e->dest != bb->next_bb)
2870 {
2871 INDENT (indent);
2872
2873 if ((flags & TDF_LINENO)
2874 #ifdef USE_MAPPED_LOCATION
2875 && e->goto_locus != UNKNOWN_LOCATION
2876 #else
2877 && e->goto_locus
2878 #endif
2879 )
2880 {
2881 expanded_location goto_xloc;
2882 #ifdef USE_MAPPED_LOCATION
2883 goto_xloc = expand_location (e->goto_locus);
2884 #else
2885 goto_xloc = *e->goto_locus;
2886 #endif
2887 pp_character (buffer, '[');
2888 if (goto_xloc.file)
2889 {
2890 pp_string (buffer, goto_xloc.file);
2891 pp_string (buffer, " : ");
2892 }
2893 pp_decimal_int (buffer, goto_xloc.line);
2894 pp_string (buffer, "] ");
2895 }
2896
2897 pp_cfg_jump (buffer, e->dest);
2898 pp_newline (buffer);
2899 }
2900 }
2901
2902 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2903 indented by INDENT spaces. */
2904
2905 static void
2906 dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
2907 int indent, int flags)
2908 {
2909 block_stmt_iterator bsi;
2910 tree stmt;
2911 int label_indent = indent - 2;
2912
2913 if (label_indent < 0)
2914 label_indent = 0;
2915
2916 dump_bb_header (buffer, bb, indent, flags);
2917
2918 dump_phi_nodes (buffer, bb, indent, flags);
2919
2920 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2921 {
2922 int curr_indent;
2923
2924 stmt = bsi_stmt (bsi);
2925
2926 curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
2927
2928 INDENT (curr_indent);
2929 dump_generic_node (buffer, stmt, curr_indent, flags, true);
2930 pp_newline (buffer);
2931 }
2932
2933 dump_implicit_edges (buffer, bb, indent, flags);
2934
2935 if (flags & TDF_BLOCKS)
2936 dump_bb_end (buffer, bb, indent, flags);
2937 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org