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