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