]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/tree-pretty-print.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* gimplify.c (sort_case_labels): New. Split out from...
[thirdparty/gcc.git] / gcc / tree-pretty-print.c
CommitLineData
4ee9c684 1/* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 2, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING. If not, write to the Free
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2002111-1307, USA. */
21
22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "tm.h"
26#include "errors.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
35/* Local functions, macros and variables. */
36static int op_prio (tree);
37static const char *op_symbol (tree);
38static void pretty_print_string (pretty_printer *, const char*);
39static void print_call_name (pretty_printer *, tree);
40static void newline_and_indent (pretty_printer *, int);
41static void maybe_init_pretty_print (FILE *);
42static void print_declaration (pretty_printer *, tree, int, int);
43static void print_struct_decl (pretty_printer *, tree, int, int);
44static void do_niy (pretty_printer *, tree);
45static void dump_vops (pretty_printer *, tree, int, int);
46static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
47
48#define INDENT(SPACE) do { \
49 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
50
51#define NIY do_niy(buffer,node)
52
53#define PRINT_FUNCTION_NAME(NODE) pp_printf \
54 (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \
5135beeb 55 lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
56 lang_hooks.decl_printable_name (NODE, 1))
4ee9c684 57
58#define MASK_POINTER(P) ((unsigned)((unsigned long)(P) & 0xffff))
59
60static pretty_printer buffer;
61static int initialized = 0;
62static bool dumping_stmts;
63
64/* Try to print something for an unknown tree code. */
65
66static void
67do_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 (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (node))))
75 {
76 len = first_rtl_op (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
87void
88debug_generic_expr (tree t)
89{
90 print_generic_expr (stderr, t, TDF_VOPS|TDF_UID);
91 fprintf (stderr, "\n");
92}
93
94void
95debug_generic_stmt (tree t)
96{
97 print_generic_stmt (stderr, t, TDF_VOPS|TDF_UID);
98 fprintf (stderr, "\n");
99}
100
101/* Prints declaration DECL to the FILE with details specified by FLAGS. */
102void
103print_generic_decl (FILE *file, tree decl, int flags)
104{
105 maybe_init_pretty_print (file);
106 dumping_stmts = true;
107 print_declaration (&buffer, decl, 2, flags);
108 pp_write_text_to_stream (&buffer);
109}
110
111/* Print tree T, and its successors, on file FILE. FLAGS specifies details
112 to show in the dump. See TDF_* in tree.h. */
113
114void
115print_generic_stmt (FILE *file, tree t, int flags)
116{
117 maybe_init_pretty_print (file);
118 dumping_stmts = true;
119 dump_generic_node (&buffer, t, 0, flags, true);
120 pp_flush (&buffer);
121}
122
123/* Print tree T, and its successors, on file FILE. FLAGS specifies details
124 to show in the dump. See TDF_* in tree.h. The output is indented by
125 INDENT spaces. */
126
127void
128print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
129{
130 int i;
131
132 maybe_init_pretty_print (file);
133 dumping_stmts = true;
134
135 for (i = 0; i < indent; i++)
136 pp_space (&buffer);
137 dump_generic_node (&buffer, t, indent, flags, true);
138 pp_flush (&buffer);
139}
140
141/* Print a single expression T on file FILE. FLAGS specifies details to show
142 in the dump. See TDF_* in tree.h. */
143
144void
145print_generic_expr (FILE *file, tree t, int flags)
146{
147 maybe_init_pretty_print (file);
148 dumping_stmts = false;
149 dump_generic_node (&buffer, t, 0, flags, false);
150}
151
152/* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
153 in FLAGS. */
154
155static void
156dump_decl_name (pretty_printer *buffer, tree node, int flags)
157{
158 if (DECL_NAME (node))
159 pp_tree_identifier (buffer, DECL_NAME (node));
160
161 if ((flags & TDF_UID)
162 || DECL_NAME (node) == NULL_TREE)
163 {
164 if (TREE_CODE (node) == LABEL_DECL
165 && LABEL_DECL_UID (node) != -1)
166 pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
167 LABEL_DECL_UID (node));
168 else
169 pp_printf (buffer, "<D%u>", DECL_UID (node));
170 }
171}
172
173/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
174 FLAGS specifies details to show in the dump (see TDF_* in tree.h). If
175 IS_STMT is true, the object printed is considered to be a statement
176 and it is terminated by ';' if appropriate. */
177
178int
179dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
180 bool is_stmt)
181{
182 tree type;
183 tree op0, op1;
184 const char* str;
185 bool is_expr;
186
187 if (node == NULL_TREE)
188 return spc;
189
190 is_expr = EXPR_P (node);
191
192 if (TREE_CODE (node) != ERROR_MARK
193 && is_gimple_stmt (node)
194 && (flags & TDF_VOPS)
195 && stmt_ann (node))
196 dump_vops (buffer, node, spc, flags);
197
198 if (dumping_stmts
199 && (flags & TDF_LINENO)
200 && EXPR_HAS_LOCATION (node))
201 {
202 pp_character (buffer, '[');
203 if (EXPR_FILENAME (node))
204 {
205 pp_string (buffer, EXPR_FILENAME (node));
206 pp_string (buffer, " : ");
207 }
208 pp_decimal_int (buffer, EXPR_LINENO (node));
209 pp_string (buffer, "] ");
210 }
211
212 switch (TREE_CODE (node))
213 {
214 case ERROR_MARK:
215 pp_string (buffer, "<<< error >>>");
216 break;
217
218 case IDENTIFIER_NODE:
219 pp_tree_identifier (buffer, node);
220 break;
221
222 case TREE_LIST:
223 while (node && node != error_mark_node)
224 {
225 if (TREE_PURPOSE (node))
226 {
227 dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
228 pp_space (buffer);
229 }
230 dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
231 node = TREE_CHAIN (node);
232 if (node && TREE_CODE (node) == TREE_LIST)
233 {
234 pp_character (buffer, ',');
235 pp_space (buffer);
236 }
237 }
238 break;
239
240 case TREE_VEC:
241 dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
242 break;
243
244 case BLOCK:
245 NIY;
246 break;
247
248 case VOID_TYPE:
249 case INTEGER_TYPE:
250 case REAL_TYPE:
251 case COMPLEX_TYPE:
252 case VECTOR_TYPE:
253 case ENUMERAL_TYPE:
254 case BOOLEAN_TYPE:
255 case CHAR_TYPE:
256 {
257 unsigned int quals = TYPE_QUALS (node);
258 char class;
259
260 if (quals & TYPE_QUAL_CONST)
261 pp_string (buffer, "const ");
262 else if (quals & TYPE_QUAL_VOLATILE)
263 pp_string (buffer, "volatile ");
264 else if (quals & TYPE_QUAL_RESTRICT)
265 pp_string (buffer, "restrict ");
266
267 class = TREE_CODE_CLASS (TREE_CODE (node));
268
269 if (class == 'd')
270 {
271 if (DECL_NAME (node))
272 dump_decl_name (buffer, node, flags);
273 else
274 pp_string (buffer, "<unnamed type decl>");
275 }
276 else if (class == 't')
277 {
278 if (TYPE_NAME (node))
279 {
280 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
281 pp_tree_identifier (buffer, TYPE_NAME (node));
282 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
283 && DECL_NAME (TYPE_NAME (node)))
284 dump_decl_name (buffer, TYPE_NAME (node), flags);
285 else
286 pp_string (buffer, "<unnamed type>");
287 }
288 else
289 pp_string (buffer, "<unnamed type>");
290 }
291 break;
292 }
293
294 case POINTER_TYPE:
295 case REFERENCE_TYPE:
296 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
297
298 if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
299 {
300 tree fnode = TREE_TYPE (node);
301 dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
302 pp_space (buffer);
303 pp_character (buffer, '(');
304 pp_string (buffer, str);
305 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
306 dump_decl_name (buffer, TYPE_NAME (node), flags);
307 else
308 pp_printf (buffer, "<T%x>", TYPE_UID (node));
309
310 pp_character (buffer, ')');
311 pp_space (buffer);
312 pp_character (buffer, '(');
313 /* Print the argument types. The last element in the list is a
314 VOID_TYPE. The following avoid to print the last element. */
315 {
316 tree tmp = TYPE_ARG_TYPES (fnode);
317 while (tmp && TREE_CHAIN (tmp) && tmp != error_mark_node)
318 {
319 dump_generic_node (buffer, TREE_VALUE (tmp), spc, flags, false);
320 tmp = TREE_CHAIN (tmp);
321 if (TREE_CHAIN (tmp) && TREE_CODE (TREE_CHAIN (tmp)) == TREE_LIST)
322 {
323 pp_character (buffer, ',');
324 pp_space (buffer);
325 }
326 }
327 }
328 pp_character (buffer, ')');
329 }
330 else
331 {
332 unsigned int quals = TYPE_QUALS (node);
333
334 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
335 pp_space (buffer);
336 pp_string (buffer, str);
337
338 if (quals & TYPE_QUAL_CONST)
339 pp_string (buffer, " const");
340 else if (quals & TYPE_QUAL_VOLATILE)
341 pp_string (buffer, "volatile");
342 else if (quals & TYPE_QUAL_RESTRICT)
343 pp_string (buffer, " restrict");
344 }
345 break;
346
347 case OFFSET_TYPE:
348 NIY;
349 break;
350
351 case METHOD_TYPE:
352 dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
353 pp_string (buffer, "::");
354 break;
355
356 case FILE_TYPE:
357 NIY;
358 break;
359
360 case ARRAY_TYPE:
361 {
362 tree tmp;
363
364 /* Print the array type. */
365 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
366
367 /* Print the dimensions. */
368 tmp = node;
369 while (tmp && TREE_CODE (tmp) == ARRAY_TYPE)
370 {
371 pp_character (buffer, '[');
372 if (TYPE_SIZE (tmp))
373 {
374 tree size = TYPE_SIZE (tmp);
375 if (TREE_CODE (size) == INTEGER_CST)
376 pp_wide_integer (buffer,
377 TREE_INT_CST_LOW (TYPE_SIZE (tmp)) /
378 TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tmp))));
379 else if (TREE_CODE (size) == MULT_EXPR)
380 dump_generic_node (buffer, TREE_OPERAND (size, 0), spc, flags, false);
381 /* else punt. */
382 }
383 pp_character (buffer, ']');
384 tmp = TREE_TYPE (tmp);
385 }
386 break;
387 }
388
389 case SET_TYPE:
390 NIY;
391 break;
392
393 case RECORD_TYPE:
394 case UNION_TYPE:
395 /* Print the name of the structure. */
396 if (TREE_CODE (node) == RECORD_TYPE)
397 pp_string (buffer, "struct ");
398 else if (TREE_CODE (node) == UNION_TYPE)
399 pp_string (buffer, "union ");
400
401 if (TYPE_NAME (node))
402 dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
403 else
404 print_struct_decl (buffer, node, spc, flags);
405 break;
406
407 case QUAL_UNION_TYPE:
408 NIY;
409 break;
410
411
412 case LANG_TYPE:
413 NIY;
414 break;
415
416 case INTEGER_CST:
417 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
418 {
419 /* In the case of a pointer, one may want to divide by the
420 size of the pointed-to type. Unfortunately, this not
421 straightforward. The C front-end maps expressions
422
423 (int *) 5
424 int *p; (p + 5)
425
426 in such a way that the two INTEGER_CST nodes for "5" have
427 different values but identical types. In the latter
428 case, the 5 is multiplied by sizeof (int) in c-common.c
429 (pointer_int_sum) to convert it to a byte address, and
430 yet the type of the node is left unchanged. Argh. What
431 is consistent though is that the number value corresponds
432 to bytes (UNITS) offset.
433
434 NB: Neither of the following divisors can be trivially
435 used to recover the original literal:
436
437 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
438 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
439 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
440 pp_string (buffer, "B"); /* pseudo-unit */
441 }
442 else if (! host_integerp (node, 0))
443 {
444 tree val = node;
445
446 if (tree_int_cst_sgn (val) < 0)
447 {
448 pp_character (buffer, '-');
449 val = build_int_2 (-TREE_INT_CST_LOW (val),
450 ~TREE_INT_CST_HIGH (val)
451 + !TREE_INT_CST_LOW (val));
452 }
453 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
454 systems? */
455 {
456 static char format[10]; /* "%x%09999x\0" */
457 if (!format[0])
458 sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
459 sprintf (pp_buffer (buffer)->digit_buffer, format,
460 TREE_INT_CST_HIGH (val),
461 TREE_INT_CST_LOW (val));
462 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
463 }
464 }
465 else
466 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
467 break;
468
469 case REAL_CST:
470 /* Code copied from print_node. */
471 {
472 REAL_VALUE_TYPE d;
473 if (TREE_OVERFLOW (node))
474 pp_string (buffer, " overflow");
475
476#if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
477 d = TREE_REAL_CST (node);
478 if (REAL_VALUE_ISINF (d))
479 pp_string (buffer, " Inf");
480 else if (REAL_VALUE_ISNAN (d))
481 pp_string (buffer, " Nan");
482 else
483 {
484 char string[100];
485 real_to_decimal (string, &d, sizeof (string), 0, 1);
486 pp_string (buffer, string);
487 }
488#else
489 {
490 HOST_WIDE_INT i;
491 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
492 pp_string (buffer, "0x");
493 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
494 output_formatted_integer (buffer, "%02x", *p++);
495 }
496#endif
497 break;
498 }
499
500 case COMPLEX_CST:
501 pp_string (buffer, "__complex__ (");
502 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
503 pp_string (buffer, ", ");
504 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
505 pp_string (buffer, ")");
506 break;
507
508 case STRING_CST:
509 pp_string (buffer, "\"");
510 pretty_print_string (buffer, TREE_STRING_POINTER (node));
511 pp_string (buffer, "\"");
512 break;
513
514 case VECTOR_CST:
515 {
516 tree elt;
517 pp_string (buffer, "{ ");
518 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
519 {
520 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
521 if (TREE_CHAIN (elt))
522 pp_string (buffer, ", ");
523 }
524 pp_string (buffer, " }");
525 }
526 break;
527
528 case FUNCTION_TYPE:
529 break;
530
531 case FUNCTION_DECL:
532 case CONST_DECL:
533 dump_decl_name (buffer, node, flags);
534 break;
535
536 case LABEL_DECL:
537 if (DECL_NAME (node))
538 dump_decl_name (buffer, node, flags);
539 else if (LABEL_DECL_UID (node) != -1)
540 pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
541 LABEL_DECL_UID (node));
542 else
543 pp_printf (buffer, "<D%u>", DECL_UID (node));
544 break;
545
546 case TYPE_DECL:
547 if (strcmp (DECL_SOURCE_FILE (node), "<built-in>") == 0)
548 {
549 /* Don't print the declaration of built-in types. */
550 break;
551 }
552 if (DECL_NAME (node))
553 {
554 dump_decl_name (buffer, node, flags);
555 }
556 else
557 {
558 if (TYPE_METHODS (TREE_TYPE (node)))
559 {
560 /* The type is a c++ class: all structures have at least
561 4 methods. */
562 pp_string (buffer, "class ");
563 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
564 }
565 else
566 {
567 pp_string (buffer, "struct ");
568 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
569 pp_character (buffer, ';');
570 pp_newline (buffer);
571 }
572 }
573 break;
574
575 case VAR_DECL:
576 case PARM_DECL:
577 case FIELD_DECL:
578 case NAMESPACE_DECL:
579 dump_decl_name (buffer, node, flags);
580 break;
581
582 case RESULT_DECL:
583 pp_string (buffer, "<retval>");
584 break;
585
586 case COMPONENT_REF:
587 op0 = TREE_OPERAND (node, 0);
588 str = ".";
589 if (TREE_CODE (op0) == INDIRECT_REF)
590 {
591 op0 = TREE_OPERAND (op0, 0);
592 str = "->";
593 }
594 if (op_prio (op0) < op_prio (node))
595 pp_character (buffer, '(');
596 dump_generic_node (buffer, op0, spc, flags, false);
597 if (op_prio (op0) < op_prio (node))
598 pp_character (buffer, ')');
599 pp_string (buffer, str);
600 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
601 break;
602
603 case BIT_FIELD_REF:
604 pp_string (buffer, "BIT_FIELD_REF <");
605 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
606 pp_string (buffer, ", ");
607 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
608 pp_string (buffer, ", ");
609 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
610 pp_string (buffer, ">");
611 break;
612
613 case BUFFER_REF:
614 NIY;
615 break;
616
617 case ARRAY_REF:
618 op0 = TREE_OPERAND (node, 0);
619 if (op_prio (op0) < op_prio (node))
620 pp_character (buffer, '(');
621 dump_generic_node (buffer, op0, spc, flags, false);
622 if (op_prio (op0) < op_prio (node))
623 pp_character (buffer, ')');
624 pp_character (buffer, '[');
625 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
626 pp_character (buffer, ']');
627 break;
628
629 case ARRAY_RANGE_REF:
630 NIY;
631 break;
632
633 case CONSTRUCTOR:
634 {
635 tree lnode;
636 bool is_struct_init = FALSE;
637 pp_character (buffer, '{');
638 lnode = CONSTRUCTOR_ELTS (node);
639 if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
640 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
641 is_struct_init = TRUE;
642 while (lnode && lnode != error_mark_node)
643 {
644 tree val;
645 if (TREE_PURPOSE (lnode) && is_struct_init)
646 {
647 pp_character (buffer, '.');
648 dump_generic_node (buffer, TREE_PURPOSE (lnode), spc, flags, false);
649 pp_string (buffer, "=");
650 }
651 val = TREE_VALUE (lnode);
652 if (val && TREE_CODE (val) == ADDR_EXPR)
653 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
654 val = TREE_OPERAND (val, 0);
655 if (val && TREE_CODE (val) == FUNCTION_DECL)
656 {
657 dump_decl_name (buffer, val, flags);
658 }
659 else
660 {
661 dump_generic_node (buffer, TREE_VALUE (lnode), spc, flags, false);
662 }
663 lnode = TREE_CHAIN (lnode);
664 if (lnode && TREE_CODE (lnode) == TREE_LIST)
665 {
666 pp_character (buffer, ',');
667 pp_space (buffer);
668 }
669 }
670 pp_character (buffer, '}');
671 }
672 break;
673
674 case COMPOUND_EXPR:
675 {
676 tree *tp;
677 if (flags & TDF_SLIM)
678 {
679 pp_string (buffer, "<COMPOUND_EXPR>");
680 break;
681 }
682
683 dump_generic_node (buffer, TREE_OPERAND (node, 0),
684 spc, flags, dumping_stmts);
685 if (dumping_stmts)
686 newline_and_indent (buffer, spc);
687 else
688 {
689 pp_character (buffer, ',');
690 pp_space (buffer);
691 }
692
693 for (tp = &TREE_OPERAND (node, 1);
694 TREE_CODE (*tp) == COMPOUND_EXPR;
695 tp = &TREE_OPERAND (*tp, 1))
696 {
697 dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
698 spc, flags, dumping_stmts);
699 if (dumping_stmts)
700 newline_and_indent (buffer, spc);
701 else
702 {
703 pp_character (buffer, ',');
704 pp_space (buffer);
705 }
706 }
707
708 dump_generic_node (buffer, *tp, spc, flags, dumping_stmts);
709 }
710 break;
711
712 case STATEMENT_LIST:
713 {
714 tree_stmt_iterator si;
715 bool first = true;
716
717 if ((flags & TDF_SLIM) || !dumping_stmts)
718 {
719 pp_string (buffer, "<STATEMENT_LIST>");
720 break;
721 }
722
723 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
724 {
725 if (!first)
726 newline_and_indent (buffer, spc);
727 else
728 first = false;
729 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
730 }
731 }
732 break;
733
734 case MODIFY_EXPR:
735 case INIT_EXPR:
736 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
737 pp_space (buffer);
738 pp_character (buffer, '=');
739 pp_space (buffer);
740 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
741 break;
742
743 case TARGET_EXPR:
744 dump_generic_node (buffer, TYPE_NAME (TREE_TYPE (node)), spc, flags, false);
745 pp_character (buffer, '(');
746 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
747 pp_character (buffer, ')');
748 break;
749
750 case COND_EXPR:
751 if (TREE_TYPE (node) == void_type_node)
752 {
753 pp_string (buffer, "if (");
754 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
755 pp_character (buffer, ')');
756 /* The lowered cond_exprs should always be printed in full. */
757 if (COND_EXPR_THEN (node)
758 && TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR
759 && COND_EXPR_ELSE (node)
760 && TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR)
761 {
762 pp_space (buffer);
763 dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);
764 pp_string (buffer, " else ");
765 dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true);
766 }
767 else if (!(flags & TDF_SLIM))
768 {
769 /* Output COND_EXPR_THEN. */
770 if (COND_EXPR_THEN (node))
771 {
772 newline_and_indent (buffer, spc+2);
773 pp_character (buffer, '{');
774 newline_and_indent (buffer, spc+4);
775 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
776 flags, true);
777 newline_and_indent (buffer, spc+2);
778 pp_character (buffer, '}');
779 }
780
781 /* Output COND_EXPR_ELSE. */
782 if (COND_EXPR_ELSE (node))
783 {
784 newline_and_indent (buffer, spc);
785 pp_string (buffer, "else");
786 newline_and_indent (buffer, spc+2);
787 pp_character (buffer, '{');
788 newline_and_indent (buffer, spc+4);
789 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
790 flags, true);
791 newline_and_indent (buffer, spc+2);
792 pp_character (buffer, '}');
793 }
794 }
795 is_expr = false;
796 }
797 else
798 {
799 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
800 pp_space (buffer);
801 pp_character (buffer, '?');
802 pp_space (buffer);
803 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
804 pp_space (buffer);
805 pp_character (buffer, ':');
806 pp_space (buffer);
807 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
808 }
809 break;
810
811 case BIND_EXPR:
812 pp_character (buffer, '{');
813 if (!(flags & TDF_SLIM))
814 {
815 if (BIND_EXPR_VARS (node))
816 {
817 pp_newline (buffer);
818
819 for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
820 {
821 print_declaration (buffer, op0, spc+2, flags);
822 pp_newline (buffer);
823 }
824 }
825
826 newline_and_indent (buffer, spc+2);
827 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
828 newline_and_indent (buffer, spc);
829 pp_character (buffer, '}');
830 }
831 is_expr = false;
832 break;
833
834 case CALL_EXPR:
835 print_call_name (buffer, node);
836
837 /* Print parameters. */
838 pp_space (buffer);
839 pp_character (buffer, '(');
840 op1 = TREE_OPERAND (node, 1);
841 if (op1)
842 dump_generic_node (buffer, op1, spc, flags, false);
843 pp_character (buffer, ')');
844
845 op1 = TREE_OPERAND (node, 2);
846 if (op1)
847 {
848 pp_string (buffer, " [static-chain: ");
849 dump_generic_node (buffer, op1, spc, flags, false);
850 pp_character (buffer, ']');
851 }
852
853 if (CALL_EXPR_TAILCALL (node))
854 pp_string (buffer, " [tail call]");
855 break;
856
857 case WITH_CLEANUP_EXPR:
858 NIY;
859 break;
860
861 case CLEANUP_POINT_EXPR:
862 pp_string (buffer, "<<cleanup_point ");
863 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
864 pp_string (buffer, ">>");
865 break;
866
867 case PLACEHOLDER_EXPR:
868 NIY;
869 break;
870
871 /* Binary arithmetic and logic expressions. */
872 case MULT_EXPR:
873 case PLUS_EXPR:
874 case MINUS_EXPR:
875 case TRUNC_DIV_EXPR:
876 case CEIL_DIV_EXPR:
877 case FLOOR_DIV_EXPR:
878 case ROUND_DIV_EXPR:
879 case TRUNC_MOD_EXPR:
880 case CEIL_MOD_EXPR:
881 case FLOOR_MOD_EXPR:
882 case ROUND_MOD_EXPR:
883 case RDIV_EXPR:
884 case EXACT_DIV_EXPR:
885 case LSHIFT_EXPR:
886 case RSHIFT_EXPR:
887 case LROTATE_EXPR:
888 case RROTATE_EXPR:
889 case BIT_IOR_EXPR:
890 case BIT_XOR_EXPR:
891 case BIT_AND_EXPR:
892 case TRUTH_ANDIF_EXPR:
893 case TRUTH_ORIF_EXPR:
894 case TRUTH_AND_EXPR:
895 case TRUTH_OR_EXPR:
896 case TRUTH_XOR_EXPR:
897 case LT_EXPR:
898 case LE_EXPR:
899 case GT_EXPR:
900 case GE_EXPR:
901 case EQ_EXPR:
902 case NE_EXPR:
903 case UNLT_EXPR:
904 case UNLE_EXPR:
905 case UNGT_EXPR:
906 case UNGE_EXPR:
907 case UNEQ_EXPR:
318a728f 908 case LTGT_EXPR:
909 case ORDERED_EXPR:
910 case UNORDERED_EXPR:
4ee9c684 911 {
912 const char *op = op_symbol (node);
913 op0 = TREE_OPERAND (node, 0);
914 op1 = TREE_OPERAND (node, 1);
915
916 /* When the operands are expressions with less priority,
917 keep semantics of the tree representation. */
918 if (op_prio (op0) < op_prio (node))
919 {
920 pp_character (buffer, '(');
921 dump_generic_node (buffer, op0, spc, flags, false);
922 pp_character (buffer, ')');
923 }
924 else
925 dump_generic_node (buffer, op0, spc, flags, false);
926
927 pp_space (buffer);
928 pp_string (buffer, op);
929 pp_space (buffer);
930
931 /* When the operands are expressions with less priority,
932 keep semantics of the tree representation. */
933 if (op_prio (op1) < op_prio (node))
934 {
935 pp_character (buffer, '(');
936 dump_generic_node (buffer, op1, spc, flags, false);
937 pp_character (buffer, ')');
938 }
939 else
940 dump_generic_node (buffer, op1, spc, flags, false);
941 }
942 break;
943
944 /* Unary arithmetic and logic expressions. */
945 case NEGATE_EXPR:
946 case BIT_NOT_EXPR:
947 case TRUTH_NOT_EXPR:
948 case ADDR_EXPR:
949 case REFERENCE_EXPR:
950 case PREDECREMENT_EXPR:
951 case PREINCREMENT_EXPR:
952 case INDIRECT_REF:
953 if (TREE_CODE (node) == ADDR_EXPR
954 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
955 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
956 ; /* Do not output '&' for strings and function pointers. */
957 else
958 pp_string (buffer, op_symbol (node));
959
960 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
961 {
962 pp_character (buffer, '(');
963 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
964 pp_character (buffer, ')');
965 }
966 else
967 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
968 break;
969
970 case POSTDECREMENT_EXPR:
971 case POSTINCREMENT_EXPR:
972 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
973 {
974 pp_character (buffer, '(');
975 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
976 pp_character (buffer, ')');
977 }
978 else
979 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
980 pp_string (buffer, op_symbol (node));
981 break;
982
983 case MIN_EXPR:
984 pp_string (buffer, "MIN_EXPR <");
985 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
986 pp_string (buffer, ", ");
987 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
988 pp_character (buffer, '>');
989 break;
990
991 case MAX_EXPR:
992 pp_string (buffer, "MAX_EXPR <");
993 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
994 pp_string (buffer, ", ");
995 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
996 pp_character (buffer, '>');
997 break;
998
999 case ABS_EXPR:
1000 pp_string (buffer, "ABS_EXPR <");
1001 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1002 pp_character (buffer, '>');
1003 break;
1004
4ee9c684 1005 case IN_EXPR:
1006 NIY;
1007 break;
1008
1009 case SET_LE_EXPR:
1010 NIY;
1011 break;
1012
1013 case CARD_EXPR:
1014 NIY;
1015 break;
1016
1017 case RANGE_EXPR:
1018 NIY;
1019 break;
1020
1021 case FIX_TRUNC_EXPR:
1022 case FIX_CEIL_EXPR:
1023 case FIX_FLOOR_EXPR:
1024 case FIX_ROUND_EXPR:
1025 case FLOAT_EXPR:
1026 case CONVERT_EXPR:
1027 case NOP_EXPR:
1028 type = TREE_TYPE (node);
1029 op0 = TREE_OPERAND (node, 0);
1030 if (type != TREE_TYPE (op0))
1031 {
1032 pp_character (buffer, '(');
1033 dump_generic_node (buffer, type, spc, flags, false);
1034 pp_string (buffer, ")");
1035 }
1036 if (op_prio (op0) < op_prio (node))
1037 pp_character (buffer, '(');
1038 dump_generic_node (buffer, op0, spc, flags, false);
1039 if (op_prio (op0) < op_prio (node))
1040 pp_character (buffer, ')');
1041 break;
1042
1043 case VIEW_CONVERT_EXPR:
1044 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1045 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1046 pp_string (buffer, ">(");
1047 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1048 pp_character (buffer, ')');
1049 break;
1050
1051 case NON_LVALUE_EXPR:
1052 pp_string (buffer, "NON_LVALUE_EXPR <");
1053 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1054 pp_character (buffer, '>');
1055 break;
1056
1057 case SAVE_EXPR:
1058 pp_string (buffer, "SAVE_EXPR <");
1059 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1060 pp_character (buffer, '>');
1061 break;
1062
1063 case UNSAVE_EXPR:
1064 pp_string (buffer, "UNSAVE_EXPR <");
1065 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1066 pp_character (buffer, '>');
1067 break;
1068
1069 case RTL_EXPR:
1070 NIY;
1071 break;
1072
1073 case ENTRY_VALUE_EXPR:
1074 NIY;
1075 break;
1076
1077 case COMPLEX_EXPR:
1078 pp_string (buffer, "COMPLEX_EXPR <");
1079 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1080 pp_string (buffer, ", ");
1081 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1082 pp_string (buffer, ">");
1083 break;
1084
1085 case CONJ_EXPR:
1086 pp_string (buffer, "CONJ_EXPR <");
1087 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1088 pp_string (buffer, ">");
1089 break;
1090
1091 case REALPART_EXPR:
1092 pp_string (buffer, "REALPART_EXPR <");
1093 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1094 pp_string (buffer, ">");
1095 break;
1096
1097 case IMAGPART_EXPR:
1098 pp_string (buffer, "IMAGPART_EXPR <");
1099 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1100 pp_string (buffer, ">");
1101 break;
1102
1103 case VA_ARG_EXPR:
1104 pp_string (buffer, "VA_ARG_EXPR <");
1105 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1106 pp_string (buffer, ">");
1107 break;
1108
1109 case TRY_FINALLY_EXPR:
1110 case TRY_CATCH_EXPR:
1111 pp_string (buffer, "try");
1112 newline_and_indent (buffer, spc+2);
1113 pp_string (buffer, "{");
1114 newline_and_indent (buffer, spc+4);
1115 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1116 newline_and_indent (buffer, spc+2);
1117 pp_string (buffer, "}");
1118 newline_and_indent (buffer, spc);
1119 pp_string (buffer,
1120 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1121 newline_and_indent (buffer, spc+2);
1122 pp_string (buffer, "{");
1123 newline_and_indent (buffer, spc+4);
1124 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1125 newline_and_indent (buffer, spc+2);
1126 pp_string (buffer, "}");
1127 is_expr = false;
1128 break;
1129
1130 case CATCH_EXPR:
1131 pp_string (buffer, "catch (");
1132 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1133 pp_string (buffer, ")");
1134 newline_and_indent (buffer, spc+2);
1135 pp_string (buffer, "{");
1136 newline_and_indent (buffer, spc+4);
1137 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1138 newline_and_indent (buffer, spc+2);
1139 pp_string (buffer, "}");
1140 is_expr = false;
1141 break;
1142
1143 case EH_FILTER_EXPR:
1144 pp_string (buffer, "<<<eh_filter (");
1145 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1146 pp_string (buffer, ")>>>");
1147 newline_and_indent (buffer, spc+2);
1148 pp_string (buffer, "{");
1149 newline_and_indent (buffer, spc+4);
1150 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1151 newline_and_indent (buffer, spc+2);
1152 pp_string (buffer, "}");
1153 is_expr = false;
1154 break;
1155
1156 case GOTO_SUBROUTINE_EXPR:
1157 NIY;
1158 break;
1159
1160 case LABEL_EXPR:
1161 op0 = TREE_OPERAND (node, 0);
1162 /* If this is for break or continue, don't bother printing it. */
1163 if (DECL_NAME (op0))
1164 {
1165 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1166 if (strcmp (name, "break") == 0
1167 || strcmp (name, "continue") == 0)
1168 break;
1169 }
1170 dump_generic_node (buffer, op0, spc, flags, false);
1171 pp_character (buffer, ':');
1172 if (DECL_NONLOCAL (op0))
1173 pp_string (buffer, " [non-local]");
1174 break;
1175
1176 case LABELED_BLOCK_EXPR:
1177 op0 = LABELED_BLOCK_LABEL (node);
1178 /* If this is for break or continue, don't bother printing it. */
1179 if (DECL_NAME (op0))
1180 {
1181 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1182 if (strcmp (name, "break") == 0
1183 || strcmp (name, "continue") == 0)
1184 {
1185 dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc, flags, false);
1186 break;
1187 }
1188 }
1189 dump_generic_node (buffer, LABELED_BLOCK_LABEL (node), spc, flags, false);
1190 pp_string (buffer, ": {");
1191 if (!(flags & TDF_SLIM))
1192 newline_and_indent (buffer, spc+2);
1193 dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc+2, flags, true);
1194 if (!flags)
1195 newline_and_indent (buffer, spc);
1196 pp_character (buffer, '}');
1197 is_expr = false;
1198 break;
1199
1200 case EXIT_BLOCK_EXPR:
1201 op0 = LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (node));
1202 /* If this is for a break or continue, print it accordingly. */
1203 if (DECL_NAME (op0))
1204 {
1205 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1206 if (strcmp (name, "break") == 0
1207 || strcmp (name, "continue") == 0)
1208 {
1209 pp_string (buffer, name);
1210 break;
1211 }
1212 }
1213 pp_string (buffer, "<<<exit block ");
1214 dump_generic_node (buffer, op0, spc, flags, false);
1215 pp_string (buffer, ">>>");
1216 break;
1217
1218 case EXC_PTR_EXPR:
1219 pp_string (buffer, "<<<exception object>>>");
1220 break;
1221
1222 case FILTER_EXPR:
1223 pp_string (buffer, "<<<filter object>>>");
1224 break;
1225
1226 case LOOP_EXPR:
1227 pp_string (buffer, "while (1)");
1228 if (!(flags & TDF_SLIM))
1229 {
1230 newline_and_indent (buffer, spc+2);
1231 pp_character (buffer, '{');
1232 newline_and_indent (buffer, spc+4);
1233 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1234 newline_and_indent (buffer, spc+2);
1235 pp_character (buffer, '}');
1236 }
1237 is_expr = false;
1238 break;
1239
1240 case RETURN_EXPR:
1241 pp_string (buffer, "return");
1242 op0 = TREE_OPERAND (node, 0);
1243 if (op0)
1244 {
1245 pp_space (buffer);
1246 if (TREE_CODE (op0) == MODIFY_EXPR)
1247 dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);
1248 else
1249 dump_generic_node (buffer, op0, spc, flags, false);
1250 }
1251 break;
1252
1253 case EXIT_EXPR:
1254 pp_string (buffer, "if (");
1255 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1256 pp_string (buffer, ") break");
1257 break;
1258
1259 case SWITCH_EXPR:
1260 pp_string (buffer, "switch (");
1261 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1262 pp_character (buffer, ')');
1263 if (!(flags & TDF_SLIM))
1264 {
1265 newline_and_indent (buffer, spc+2);
1266 pp_character (buffer, '{');
1267 if (SWITCH_BODY (node))
1268 {
1269 newline_and_indent (buffer, spc+4);
1270 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags, true);
1271 }
1272 else
1273 {
1274 tree vec = SWITCH_LABELS (node);
1275 size_t i, n = TREE_VEC_LENGTH (vec);
1276 for (i = 0; i < n; ++i)
1277 {
1278 tree elt = TREE_VEC_ELT (vec, i);
1279 newline_and_indent (buffer, spc+4);
1280 dump_generic_node (buffer, elt, spc+4, flags, false);
1281 pp_string (buffer, " goto ");
1282 dump_generic_node (buffer, CASE_LABEL (elt), spc+4, flags, true);
1283 pp_semicolon (buffer);
1284 }
1285 }
1286 newline_and_indent (buffer, spc+2);
1287 pp_character (buffer, '}');
1288 }
1289 is_expr = false;
1290 break;
1291
1292 case GOTO_EXPR:
1293 op0 = GOTO_DESTINATION (node);
1294 if (TREE_CODE (op0) != SSA_NAME
1295 && DECL_P (op0)
1296 && DECL_NAME (op0))
1297 {
1298 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1299 if (strcmp (name, "break") == 0
1300 || strcmp (name, "continue") == 0)
1301 {
1302 pp_string (buffer, name);
1303 break;
1304 }
1305 }
1306 pp_string (buffer, "goto ");
1307 dump_generic_node (buffer, op0, spc, flags, false);
1308 break;
1309
1310 case RESX_EXPR:
1311 pp_string (buffer, "resx");
1312 /* ??? Any sensible way to present the eh region? */
1313 break;
1314
1315 case ASM_EXPR:
1316 pp_string (buffer, "__asm__");
1317 if (ASM_VOLATILE_P (node))
1318 pp_string (buffer, " __volatile__");
1319 pp_character (buffer, '(');
1320 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1321 pp_character (buffer, ':');
1322 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1323 pp_character (buffer, ':');
1324 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1325 if (ASM_CLOBBERS (node))
1326 {
1327 pp_character (buffer, ':');
1328 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1329 }
1330 pp_string (buffer, ")");
1331 break;
1332
1333 case CASE_LABEL_EXPR:
1334 if (CASE_LOW (node) && CASE_HIGH (node))
1335 {
1336 pp_string (buffer, "case ");
1337 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1338 pp_string (buffer, " ... ");
1339 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1340 }
1341 else if (CASE_LOW (node))
1342 {
1343 pp_string (buffer, "case ");
1344 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1345 }
1346 else
1347 pp_string (buffer, "default ");
1348 pp_character (buffer, ':');
1349 break;
1350
1351 case VTABLE_REF:
1352 pp_string (buffer, "VTABLE_REF <(");
1353 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1354 pp_string (buffer, "),");
1355 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1356 pp_character (buffer, ',');
1357 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1358 pp_character (buffer, '>');
1359 break;
1360
1361 case EPHI_NODE:
1362 {
1363 int i;
1364
1365 pp_string (buffer, " EPHI (");
1366 dump_generic_node (buffer, EREF_NAME (node), spc, flags, false);
1367 pp_string (buffer, ") ");
1368 pp_character (buffer, '[');
1369 pp_string (buffer, " class:");
1370 pp_decimal_int (buffer, EREF_CLASS (node));
1371 if (EPHI_DOWNSAFE (node))
1372 pp_string (buffer, " downsafe");
1373 if (EPHI_CANT_BE_AVAIL (node))
1374 pp_string (buffer, " cant_be_avail");
1375 if (EPHI_STOPS (node))
1376 pp_string (buffer, " stops");
1377 pp_string (buffer, " bb:");
1378 pp_decimal_int (buffer, bb_for_stmt (node)->index);
1379 pp_character (buffer, ']');
1380 if (! (flags & TDF_SLIM))
1381 {
1382 pp_string (buffer, " <");
1383 for (i = 0; i < EPHI_NUM_ARGS (node); i++)
1384 {
1385 if (EPHI_ARG_DEF (node, i))
1386 {
1387 newline_and_indent (buffer, spc + 2);
1388 pp_string (buffer, " edge ");
1389 pp_decimal_int (buffer, EPHI_ARG_EDGE (node, i)->src->index);
1390 pp_string (buffer, "->");
1391 pp_decimal_int (buffer, EPHI_ARG_EDGE (node, i)->dest->index);
1392 pp_string (buffer, " [ ");
1393 if (EPHI_ARG_HAS_REAL_USE (node, i))
1394 pp_string (buffer, " real use");
1395 if (EPHI_ARG_INJURED (node, i))
1396 pp_string (buffer, " injured");
1397 if (EPHI_ARG_STOPS (node, i))
1398 pp_string (buffer, " stops");
1399 pp_string (buffer, " ] ");
1400 pp_string (buffer, " defined by:");
1401 dump_generic_node (buffer, EPHI_ARG_DEF (node, i),
1402 spc + 4, flags | TDF_SLIM, false);
1403 }
1404 }
1405 }
1406 pp_string (buffer, " >");
1407 }
1408 break;
1409 case EEXIT_NODE:
1410 case EKILL_NODE:
1411 if (TREE_CODE (node) == EEXIT_NODE)
1412 pp_string (buffer, "EEXIT (");
1413 else if (TREE_CODE (node) == EKILL_NODE)
1414 pp_string (buffer, "EKILL (");
1415 dump_generic_node (buffer, EREF_NAME (node), spc, flags, false);
1416 pp_string (buffer, ") ");
1417 pp_character (buffer, '[');
1418 pp_string (buffer, "class:");
1419 pp_decimal_int (buffer, EREF_CLASS (node));
1420 pp_string (buffer, " bb:");
1421 pp_decimal_int (buffer, bb_for_stmt (node)->index);
1422 pp_character (buffer, ']');
1423 break;
1424 case EUSE_NODE:
1425 pp_string (buffer, " EUSE (");
1426 dump_generic_node (buffer, EREF_NAME (node), spc, flags, false);
1427
1428 pp_string (buffer, ") ");
1429 pp_character (buffer, '[');
1430 pp_string (buffer, "class:");
1431 pp_decimal_int (buffer, EREF_CLASS (node));
1432 pp_string (buffer, " phiop:");
1433 pp_decimal_int (buffer, EUSE_PHIOP (node));
1434 pp_string (buffer, " bb:");
1435 pp_decimal_int (buffer, bb_for_stmt (node)->index);
1436 if (EUSE_LVAL (node))
1437 pp_string (buffer, " left-occurrence");
1438 pp_string (buffer, " ]");
1439
1440 break;
1441 case PHI_NODE:
1442 {
1443 int i;
1444
1445 dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1446 pp_string (buffer, " = PHI <");
1447 for (i = 0; i < PHI_NUM_ARGS (node); i++)
1448 {
1449 dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1450 pp_string (buffer, "(");
1451 pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1452 pp_string (buffer, ")");
1453 if (i < PHI_NUM_ARGS (node) - 1)
1454 pp_string (buffer, ", ");
1455 }
1456 pp_string (buffer, ">;");
1457 }
1458 break;
1459
1460 case SSA_NAME:
1461 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1462 pp_string (buffer, "_");
1463 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1464 break;
1465
1466 default:
1467 NIY;
1468 }
1469
1470 if (is_stmt && is_expr)
1471 pp_semicolon (buffer);
1472 pp_write_text_to_stream (buffer);
1473
1474 return spc;
1475}
1476
1477/* Print the declaration of a variable. */
1478
1479static void
1480print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
1481{
1482 /* Don't print type declarations. */
1483 if (TREE_CODE (t) == TYPE_DECL)
1484 return;
1485
1486 INDENT (spc);
1487
1488 if (DECL_REGISTER (t))
1489 pp_string (buffer, "register ");
1490
1491 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
1492 pp_string (buffer, "extern ");
1493 else if (TREE_STATIC (t))
1494 pp_string (buffer, "static ");
1495
1496 /* Print the type and name. */
1497 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
1498 {
1499 tree tmp;
1500
1501 /* Print array's type. */
1502 tmp = TREE_TYPE (t);
1503 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
1504 tmp = TREE_TYPE (tmp);
1505 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
1506
1507 /* Print variable's name. */
1508 pp_space (buffer);
1509 dump_generic_node (buffer, t, spc, flags, false);
1510
1511 /* Print the dimensions. */
1512 tmp = TREE_TYPE (t);
1513 while (TREE_CODE (tmp) == ARRAY_TYPE)
1514 {
1515 pp_character (buffer, '[');
1516 if (TYPE_DOMAIN (tmp))
1517 {
1518 if (TREE_CODE (TYPE_SIZE (tmp)) == INTEGER_CST)
1519 pp_wide_integer (buffer,
1520 TREE_INT_CST_LOW (TYPE_SIZE (tmp)) /
1521 TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tmp))));
1522 else
1523 dump_generic_node (buffer, TYPE_SIZE_UNIT (tmp), spc, flags,
1524 false);
1525 }
1526 pp_character (buffer, ']');
1527 tmp = TREE_TYPE (tmp);
1528 }
1529 }
1530 else
1531 {
1532 /* Print type declaration. */
1533 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
1534
1535 /* Print variable's name. */
1536 pp_space (buffer);
1537 dump_generic_node (buffer, t, spc, flags, false);
1538 }
1539
1540 /* The initial value of a function serves to determine wether the function
1541 is declared or defined. So the following does not apply to function
1542 nodes. */
1543 if (TREE_CODE (t) != FUNCTION_DECL)
1544 {
1545 /* Print the initial value. */
1546 if (DECL_INITIAL (t))
1547 {
1548 pp_space (buffer);
1549 pp_character (buffer, '=');
1550 pp_space (buffer);
1551 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
1552 }
1553 }
1554
1555 pp_character (buffer, ';');
1556}
1557
1558
1559/* Prints a structure: name, fields, and methods.
1560 FIXME: Still incomplete. */
1561
1562static void
1563print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
1564{
1565 /* Print the name of the structure. */
1566 if (TYPE_NAME (node))
1567 {
1568 INDENT (spc);
1569 if (TREE_CODE (node) == RECORD_TYPE)
1570 pp_string (buffer, "struct ");
1571 else if (TREE_CODE (node) == UNION_TYPE)
1572 pp_string (buffer, "union ");
1573 else
1574 NIY;
1575 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
1576 }
1577
1578 /* Print the contents of the structure. */
1579 pp_newline (buffer);
1580 INDENT (spc);
1581 pp_character (buffer, '{');
1582 pp_newline (buffer);
1583
1584 /* Print the fields of the structure. */
1585 {
1586 tree tmp;
1587 tmp = TYPE_FIELDS (node);
1588 while (tmp)
1589 {
1590 /* Avoid to print recursively the structure. */
1591 /* FIXME : Not implemented correctly...,
1592 what about the case when we have a cycle in the contain graph? ...
1593 Maybe this could be solved by looking at the scope in which the
1594 structure was declared. */
1595 if (TREE_TYPE (tmp) != node
1596 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE &&
1597 TREE_TYPE (TREE_TYPE (tmp)) != node))
1598 {
1599 print_declaration (buffer, tmp, spc+2, flags);
1600 pp_newline (buffer);
1601 }
1602 else
1603 {
1604
1605 }
1606 tmp = TREE_CHAIN (tmp);
1607 }
1608 }
1609 INDENT (spc);
1610 pp_character (buffer, '}');
1611}
1612
1613/* Return the priority of the operator OP.
1614
1615 From lowest to highest precedence with either left-to-right (L-R)
1616 or right-to-left (R-L) associativity]:
1617
1618 1 [L-R] ,
1619 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
1620 3 [R-L] ?:
1621 4 [L-R] ||
1622 5 [L-R] &&
1623 6 [L-R] |
1624 7 [L-R] ^
1625 8 [L-R] &
1626 9 [L-R] == !=
1627 10 [L-R] < <= > >=
1628 11 [L-R] << >>
1629 12 [L-R] + -
1630 13 [L-R] * / %
1631 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
1632 15 [L-R] fn() [] -> .
1633
1634 unary +, - and * have higher precedence than the corresponding binary
1635 operators. */
1636
1637static int
1638op_prio (tree op)
1639{
1640 if (op == NULL)
1641 return 9999;
1642
1643 switch (TREE_CODE (op))
1644 {
1645 case TREE_LIST:
1646 case COMPOUND_EXPR:
1647 case BIND_EXPR:
1648 return 1;
1649
1650 case MODIFY_EXPR:
1651 case INIT_EXPR:
1652 return 2;
1653
1654 case COND_EXPR:
1655 return 3;
1656
1657 case TRUTH_OR_EXPR:
1658 case TRUTH_ORIF_EXPR:
1659 return 4;
1660
1661 case TRUTH_AND_EXPR:
1662 case TRUTH_ANDIF_EXPR:
1663 return 5;
1664
1665 case BIT_IOR_EXPR:
1666 return 6;
1667
1668 case BIT_XOR_EXPR:
1669 case TRUTH_XOR_EXPR:
1670 return 7;
1671
1672 case BIT_AND_EXPR:
1673 return 8;
1674
1675 case EQ_EXPR:
1676 case NE_EXPR:
1677 return 9;
1678
318a728f 1679 case UNLT_EXPR:
1680 case UNLE_EXPR:
1681 case UNGT_EXPR:
1682 case UNGE_EXPR:
1683 case UNEQ_EXPR:
1684 case LTGT_EXPR:
1685 case ORDERED_EXPR:
1686 case UNORDERED_EXPR:
4ee9c684 1687 case LT_EXPR:
1688 case LE_EXPR:
1689 case GT_EXPR:
1690 case GE_EXPR:
1691 return 10;
1692
1693 case LSHIFT_EXPR:
1694 case RSHIFT_EXPR:
1695 case LROTATE_EXPR:
1696 case RROTATE_EXPR:
1697 return 11;
1698
1699 case PLUS_EXPR:
1700 case MINUS_EXPR:
1701 return 12;
1702
1703 case MULT_EXPR:
1704 case TRUNC_DIV_EXPR:
1705 case CEIL_DIV_EXPR:
1706 case FLOOR_DIV_EXPR:
1707 case ROUND_DIV_EXPR:
1708 case RDIV_EXPR:
1709 case EXACT_DIV_EXPR:
1710 case TRUNC_MOD_EXPR:
1711 case CEIL_MOD_EXPR:
1712 case FLOOR_MOD_EXPR:
1713 case ROUND_MOD_EXPR:
1714 return 13;
1715
1716 case TRUTH_NOT_EXPR:
1717 case BIT_NOT_EXPR:
1718 case POSTINCREMENT_EXPR:
1719 case POSTDECREMENT_EXPR:
1720 case PREINCREMENT_EXPR:
1721 case PREDECREMENT_EXPR:
1722 case NEGATE_EXPR:
1723 case INDIRECT_REF:
1724 case ADDR_EXPR:
1725 case FLOAT_EXPR:
1726 case NOP_EXPR:
1727 case CONVERT_EXPR:
1728 case FIX_TRUNC_EXPR:
1729 case FIX_CEIL_EXPR:
1730 case FIX_FLOOR_EXPR:
1731 case FIX_ROUND_EXPR:
1732 case TARGET_EXPR:
1733 return 14;
1734
1735 case CALL_EXPR:
1736 case ARRAY_REF:
1737 case COMPONENT_REF:
1738 return 15;
1739
1740 /* Special expressions. */
1741 case MIN_EXPR:
1742 case MAX_EXPR:
1743 case ABS_EXPR:
1744 case REALPART_EXPR:
1745 case IMAGPART_EXPR:
1746 return 16;
1747
1748 case SAVE_EXPR:
1749 case NON_LVALUE_EXPR:
1750 return op_prio (TREE_OPERAND (op, 0));
1751
1752 default:
1753 /* Return an arbitrarily high precedence to avoid surrounding single
1754 VAR_DECLs in ()s. */
1755 return 9999;
1756 }
1757}
1758
1759
1760/* Return the symbol associated with operator OP. */
1761
1762static const char *
1763op_symbol (tree op)
1764{
1765 if (op == NULL)
1766 abort ();
1767
1768 switch (TREE_CODE (op))
1769 {
1770 case MODIFY_EXPR:
1771 return "=";
1772
1773 case TRUTH_OR_EXPR:
1774 case TRUTH_ORIF_EXPR:
1775 return "||";
1776
1777 case TRUTH_AND_EXPR:
1778 case TRUTH_ANDIF_EXPR:
1779 return "&&";
1780
1781 case BIT_IOR_EXPR:
1782 return "|";
1783
1784 case TRUTH_XOR_EXPR:
1785 case BIT_XOR_EXPR:
1786 return "^";
1787
1788 case ADDR_EXPR:
1789 case BIT_AND_EXPR:
1790 return "&";
1791
318a728f 1792 case ORDERED_EXPR:
1793 return "ord";
1794 case UNORDERED_EXPR:
1795 return "unord";
1796
4ee9c684 1797 case EQ_EXPR:
4ee9c684 1798 return "==";
318a728f 1799 case UNEQ_EXPR:
1800 return "u==";
4ee9c684 1801
1802 case NE_EXPR:
1803 return "!=";
1804
1805 case LT_EXPR:
4ee9c684 1806 return "<";
318a728f 1807 case UNLT_EXPR:
1808 return "u<";
4ee9c684 1809
1810 case LE_EXPR:
4ee9c684 1811 return "<=";
318a728f 1812 case UNLE_EXPR:
1813 return "u<=";
4ee9c684 1814
1815 case GT_EXPR:
4ee9c684 1816 return ">";
318a728f 1817 case UNGT_EXPR:
1818 return "u>";
4ee9c684 1819
1820 case GE_EXPR:
4ee9c684 1821 return ">=";
318a728f 1822 case UNGE_EXPR:
1823 return "u>=";
1824
1825 case LTGT_EXPR:
1826 return "<>";
4ee9c684 1827
1828 case LSHIFT_EXPR:
1829 return "<<";
1830
1831 case RSHIFT_EXPR:
1832 return ">>";
1833
1834 case PLUS_EXPR:
1835 return "+";
1836
1837 case NEGATE_EXPR:
1838 case MINUS_EXPR:
1839 return "-";
1840
1841 case BIT_NOT_EXPR:
1842 return "~";
1843
1844 case TRUTH_NOT_EXPR:
1845 return "!";
1846
1847 case MULT_EXPR:
1848 case INDIRECT_REF:
1849 return "*";
1850
1851 case TRUNC_DIV_EXPR:
1852 case CEIL_DIV_EXPR:
1853 case FLOOR_DIV_EXPR:
1854 case ROUND_DIV_EXPR:
1855 case RDIV_EXPR:
1856 case EXACT_DIV_EXPR:
1857 return "/";
1858
1859 case TRUNC_MOD_EXPR:
1860 case CEIL_MOD_EXPR:
1861 case FLOOR_MOD_EXPR:
1862 case ROUND_MOD_EXPR:
1863 return "%";
1864
1865 case PREDECREMENT_EXPR:
1866 return " --";
1867
1868 case PREINCREMENT_EXPR:
1869 return " ++";
1870
1871 case POSTDECREMENT_EXPR:
1872 return "-- ";
1873
1874 case POSTINCREMENT_EXPR:
1875 return "++ ";
1876
1877 case REFERENCE_EXPR:
1878 return "";
1879
1880 default:
1881 return "<<< ??? >>>";
1882 }
1883}
1884
1885/* Prints the name of a CALL_EXPR. */
1886
1887static void
1888print_call_name (pretty_printer *buffer, tree node)
1889{
1890 tree op0;
1891
1892 if (TREE_CODE (node) != CALL_EXPR)
1893 abort ();
1894
1895 op0 = TREE_OPERAND (node, 0);
1896
1897 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
1898 op0 = TREE_OPERAND (op0, 0);
1899
1900 switch (TREE_CODE (op0))
1901 {
1902 case VAR_DECL:
1903 case PARM_DECL:
1904 PRINT_FUNCTION_NAME (op0);
1905 break;
1906
1907 case ADDR_EXPR:
1908 case INDIRECT_REF:
1909 case NOP_EXPR:
1910 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1911 break;
1912
1913 case COND_EXPR:
1914 pp_string (buffer, "(");
1915 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1916 pp_string (buffer, ") ? ");
1917 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
1918 pp_string (buffer, " : ");
1919 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
1920 break;
1921
1922 case COMPONENT_REF:
1923 /* The function is a pointer contained in a structure. */
1924 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
1925 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
1926 PRINT_FUNCTION_NAME (TREE_OPERAND (op0, 1));
1927 else
1928 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1929 /* else
1930 We can have several levels of structures and a function
1931 pointer inside. This is not implemented yet... */
1932 /* NIY;*/
1933 break;
1934
1935 case ARRAY_REF:
1936 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
1937 PRINT_FUNCTION_NAME (TREE_OPERAND (op0, 0));
1938 else
1939 dump_generic_node (buffer, op0, 0, 0, false);
1940 break;
1941
1942 case SSA_NAME:
1943 dump_generic_node (buffer, op0, 0, 0, false);
1944 break;
1945
1946 default:
1947 NIY;
1948 }
1949}
1950
1951/* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
1952
1953static void
1954pretty_print_string (pretty_printer *buffer, const char *str)
1955{
1956 if (str == NULL)
1957 return;
1958
1959 while (*str)
1960 {
1961 switch (str[0])
1962 {
1963 case '\b':
1964 pp_string (buffer, "\\b");
1965 break;
1966
1967 case '\f':
1968 pp_string (buffer, "\\f");
1969 break;
1970
1971 case '\n':
1972 pp_string (buffer, "\\n");
1973 break;
1974
1975 case '\r':
1976 pp_string (buffer, "\\r");
1977 break;
1978
1979 case '\t':
1980 pp_string (buffer, "\\t");
1981 break;
1982
1983 case '\v':
1984 pp_string (buffer, "\\v");
1985 break;
1986
1987 case '\\':
1988 pp_string (buffer, "\\\\");
1989 break;
1990
1991 case '\"':
1992 pp_string (buffer, "\\\"");
1993 break;
1994
1995 case '\'':
1996 pp_string (buffer, "\\'");
1997 break;
1998
1999 case '\0':
2000 pp_string (buffer, "\\0");
2001 break;
2002
2003 case '\1':
2004 pp_string (buffer, "\\1");
2005 break;
2006
2007 case '\2':
2008 pp_string (buffer, "\\2");
2009 break;
2010
2011 case '\3':
2012 pp_string (buffer, "\\3");
2013 break;
2014
2015 case '\4':
2016 pp_string (buffer, "\\4");
2017 break;
2018
2019 case '\5':
2020 pp_string (buffer, "\\5");
2021 break;
2022
2023 case '\6':
2024 pp_string (buffer, "\\6");
2025 break;
2026
2027 case '\7':
2028 pp_string (buffer, "\\7");
2029 break;
2030
2031 default:
2032 pp_character (buffer, str[0]);
2033 break;
2034 }
2035 str++;
2036 }
2037}
2038
2039static void
2040maybe_init_pretty_print (FILE *file)
2041{
2042 if (!initialized)
2043 {
2044 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2045 pp_needs_newline (&buffer) = true;
2046 initialized = 1;
2047 }
2048
2049 buffer.buffer->stream = file;
2050}
2051
2052static void
2053newline_and_indent (pretty_printer *buffer, int spc)
2054{
2055 pp_newline (buffer);
2056 INDENT (spc);
2057}
2058
2059static void
2060dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2061{
2062 size_t i;
2063 stmt_ann_t ann = stmt_ann (stmt);
2064 vdef_optype vdefs = VDEF_OPS (ann);
2065 vuse_optype vuses = VUSE_OPS (ann);
2066
2067 for (i = 0; i < NUM_VDEFS (vdefs); i++)
2068 {
2069 pp_string (buffer, "# ");
2070 dump_generic_node (buffer, VDEF_RESULT (vdefs, i), spc + 2, flags, false);
2071 pp_string (buffer, " = VDEF <");
2072 dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, false);
2073 pp_string (buffer, ">;");
2074 newline_and_indent (buffer, spc);
2075 }
2076
2077 for (i = 0; i < NUM_VUSES (vuses); i++)
2078 {
2079 tree vuse = VUSE_OP (vuses, i);
2080 pp_string (buffer, "# VUSE <");
2081 dump_generic_node (buffer, vuse, spc + 2, flags, false);
2082 pp_string (buffer, ">;");
2083 newline_and_indent (buffer, spc);
2084 }
2085}
2086
2087/* Dumps basic block BB to FILE with details described by FLAGS and
2088 indented by INDENT spaces. */
2089
2090void
2091dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2092{
2093 maybe_init_pretty_print (file);
2094 dumping_stmts = true;
2095 dump_generic_bb_buff (&buffer, bb, indent, flags);
2096 pp_flush (&buffer);
2097}
2098
2099/* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2100 spaces and details described by flags. */
2101
2102static void
2103dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2104{
2105 edge e;
2106 tree stmt;
2107
2108 if (flags & TDF_BLOCKS)
2109 {
2110 INDENT (indent);
2111 pp_string (buffer, "# BLOCK ");
2112 pp_decimal_int (buffer, bb->index);
2113
2114 if (flags & TDF_LINENO)
2115 {
2116 block_stmt_iterator bsi;
2117
2118 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2119 if (get_lineno (bsi_stmt (bsi)) != -1)
2120 {
2121 pp_string (buffer, ", starting at line ");
2122 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2123 break;
2124 }
2125 }
2126 newline_and_indent (buffer, indent);
2127
2128 pp_string (buffer, "# PRED:");
2129 pp_write_text_to_stream (buffer);
2130 for (e = bb->pred; e; e = e->pred_next)
2131 if (flags & TDF_SLIM)
2132 {
2133 pp_string (buffer, " ");
2134 if (e->src == ENTRY_BLOCK_PTR)
2135 pp_string (buffer, "ENTRY");
2136 else
2137 pp_decimal_int (buffer, e->src->index);
2138 }
2139 else
2140 dump_edge_info (buffer->buffer->stream, e, 0);
2141 pp_newline (buffer);
2142 }
2143 else
2144 {
2145 stmt = first_stmt (bb);
2146 if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
2147 {
2148 INDENT (indent - 2);
2149 pp_string (buffer, "<bb ");
2150 pp_decimal_int (buffer, bb->index);
2151 pp_string (buffer, ">:");
2152 pp_newline (buffer);
2153 }
2154 }
2155}
2156
2157/* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2158 spaces. */
2159
2160static void
2161dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
2162{
2163 edge e;
2164
2165 INDENT (indent);
2166 pp_string (buffer, "# SUCC:");
2167 pp_write_text_to_stream (buffer);
2168 for (e = bb->succ; e; e = e->succ_next)
2169 if (flags & TDF_SLIM)
2170 {
2171 pp_string (buffer, " ");
2172 if (e->dest == EXIT_BLOCK_PTR)
2173 pp_string (buffer, "EXIT");
2174 else
2175 pp_decimal_int (buffer, e->dest->index);
2176 }
2177 else
2178 dump_edge_info (buffer->buffer->stream, e, 1);
2179 pp_newline (buffer);
2180}
2181
2182/* Dumps phi nodes of basic block BB to buffer BUFFER with details described by
2183 FLAGS indented by INDENT spaces. */
2184
2185static void
2186dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
2187{
2188 tree phi = phi_nodes (bb);
2189 if (!phi)
2190 return;
2191
2192 for (; phi; phi = TREE_CHAIN (phi))
2193 {
2194 if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
2195 {
2196 INDENT (indent);
2197 pp_string (buffer, "# ");
2198 dump_generic_node (buffer, phi, indent, flags, false);
2199 pp_newline (buffer);
2200 }
2201 }
2202}
2203
2204/* Dump jump to basic block BB that is represented implicitly in the cfg
2205 to BUFFER. */
2206
2207static void
2208pp_cfg_jump (pretty_printer *buffer, basic_block bb)
2209{
2210 tree stmt;
2211
2212 stmt = first_stmt (bb);
2213
2214 pp_string (buffer, "goto <bb ");
2215 pp_decimal_int (buffer, bb->index);
2216 pp_string (buffer, ">");
2217 if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
2218 {
2219 pp_string (buffer, " (");
2220 dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
2221 pp_string (buffer, ")");
2222 }
2223 pp_semicolon (buffer);
2224}
2225
2226/* Dump edges represented implicitly in basic block BB to BUFFER, indented
2227 by INDENT spaces, with details given by FLAGS. */
2228
2229static void
2230dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent)
2231{
2232 edge e;
2233
2234 /* If there is a fallthru edge, we may need to add an artificial goto to the
2235 dump. */
2236 for (e = bb->succ; e; e = e->succ_next)
2237 if (e->flags & EDGE_FALLTHRU)
2238 break;
2239 if (e && e->dest != bb->next_bb)
2240 {
2241 INDENT (indent);
2242 pp_cfg_jump (buffer, e->dest);
2243 pp_newline (buffer);
2244 }
2245}
2246
2247/* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2248 indented by INDENT spaces. */
2249
2250static void
2251dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
2252 int indent, int flags)
2253{
2254 block_stmt_iterator bsi;
2255 tree stmt;
2256 int label_indent = indent - 2;
2257
2258 if (label_indent < 0)
2259 label_indent = 0;
2260
2261 dump_bb_header (buffer, bb, indent, flags);
2262
2263 if (bb_ann (bb))
2264 dump_phi_nodes (buffer, bb, indent, flags);
2265
2266 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2267 {
2268 int curr_indent;
2269
2270 stmt = bsi_stmt (bsi);
2271
2272 curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
2273
2274 INDENT (curr_indent);
2275 dump_generic_node (buffer, stmt, curr_indent, flags, true);
2276 pp_newline (buffer);
2277 }
2278
2279 dump_implicit_edges (buffer, bb, indent);
2280
2281 if (flags & TDF_BLOCKS)
2282 dump_bb_end (buffer, bb, indent, flags);
2283}
Mirror of https://gcc.gnu.org/git/gcc.git