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