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