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