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