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