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