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