?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Daily bump.
[official-gcc.git] / gcc / tree-pretty-print.c
blob1faeab182dc58746771aa1778eba294cac2c230a
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,
788 (unsigned HOST_WIDE_INT) high, low);
789 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
790 }
791 else
792 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
793 break;
794
795 case REAL_CST:
796 /* Code copied from print_node. */
797 {
798 REAL_VALUE_TYPE d;
799 if (TREE_OVERFLOW (node))
800 pp_string (buffer, " overflow");
801
802 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
803 d = TREE_REAL_CST (node);
804 if (REAL_VALUE_ISINF (d))
805 pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
806 else if (REAL_VALUE_ISNAN (d))
807 pp_string (buffer, " Nan");
808 else
809 {
810 char string[100];
811 real_to_decimal (string, &d, sizeof (string), 0, 1);
812 pp_string (buffer, string);
813 }
814 #else
815 {
816 HOST_WIDE_INT i;
817 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
818 pp_string (buffer, "0x");
819 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
820 output_formatted_integer (buffer, "%02x", *p++);
821 }
822 #endif
823 break;
824 }
825
826 case FIXED_CST:
827 {
828 char string[100];
829 fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
830 pp_string (buffer, string);
831 break;
832 }
833
834 case COMPLEX_CST:
835 pp_string (buffer, "__complex__ (");
836 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
837 pp_string (buffer, ", ");
838 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
839 pp_string (buffer, ")");
840 break;
841
842 case STRING_CST:
843 pp_string (buffer, "\"");
844 pretty_print_string (buffer, TREE_STRING_POINTER (node));
845 pp_string (buffer, "\"");
846 break;
847
848 case VECTOR_CST:
849 {
850 tree elt;
851 pp_string (buffer, "{ ");
852 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
853 {
854 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
855 if (TREE_CHAIN (elt))
856 pp_string (buffer, ", ");
857 }
858 pp_string (buffer, " }");
859 }
860 break;
861
862 case FUNCTION_TYPE:
863 break;
864
865 case FUNCTION_DECL:
866 case CONST_DECL:
867 dump_decl_name (buffer, node, flags);
868 break;
869
870 case LABEL_DECL:
871 if (DECL_NAME (node))
872 dump_decl_name (buffer, node, flags);
873 else if (LABEL_DECL_UID (node) != -1)
874 pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));
875 else
876 pp_printf (buffer, "<D.%u>", DECL_UID (node));
877 break;
878
879 case TYPE_DECL:
880 if (DECL_IS_BUILTIN (node))
881 {
882 /* Don't print the declaration of built-in types. */
883 break;
884 }
885 if (DECL_NAME (node))
886 dump_decl_name (buffer, node, flags);
887 else
888 {
889 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
890 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
891 && TYPE_METHODS (TREE_TYPE (node)))
892 {
893 /* The type is a c++ class: all structures have at least
894 4 methods. */
895 pp_string (buffer, "class ");
896 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
897 }
898 else
899 {
900 pp_string (buffer,
901 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
902 ? "union" : "struct "));
903 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
904 }
905 }
906 break;
907
908 case SYMBOL_MEMORY_TAG:
909 case NAME_MEMORY_TAG:
910 case STRUCT_FIELD_TAG:
911 case VAR_DECL:
912 case PARM_DECL:
913 case FIELD_DECL:
914 case NAMESPACE_DECL:
915 case MEMORY_PARTITION_TAG:
916 dump_decl_name (buffer, node, flags);
917 break;
918
919 case RESULT_DECL:
920 pp_string (buffer, "<retval>");
921 break;
922
923 case COMPONENT_REF:
924 op0 = TREE_OPERAND (node, 0);
925 str = ".";
926 if (TREE_CODE (op0) == INDIRECT_REF)
927 {
928 op0 = TREE_OPERAND (op0, 0);
929 str = "->";
930 }
931 if (op_prio (op0) < op_prio (node))
932 pp_character (buffer, '(');
933 dump_generic_node (buffer, op0, spc, flags, false);
934 if (op_prio (op0) < op_prio (node))
935 pp_character (buffer, ')');
936 pp_string (buffer, str);
937 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
938
939 if (TREE_CODE (op0) != VALUE_HANDLE)
940 {
941 op0 = component_ref_field_offset (node);
942 if (op0 && TREE_CODE (op0) != INTEGER_CST)
943 {
944 pp_string (buffer, "{off: ");
945 dump_generic_node (buffer, op0, spc, flags, false);
946 pp_character (buffer, '}');
947 }
948 }
949 break;
950
951 case BIT_FIELD_REF:
952 pp_string (buffer, "BIT_FIELD_REF <");
953 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
954 pp_string (buffer, ", ");
955 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
956 pp_string (buffer, ", ");
957 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
958 pp_string (buffer, ">");
959 break;
960
961 case ARRAY_REF:
962 case ARRAY_RANGE_REF:
963 op0 = TREE_OPERAND (node, 0);
964 if (op_prio (op0) < op_prio (node))
965 pp_character (buffer, '(');
966 dump_generic_node (buffer, op0, spc, flags, false);
967 if (op_prio (op0) < op_prio (node))
968 pp_character (buffer, ')');
969 pp_character (buffer, '[');
970 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
971 if (TREE_CODE (node) == ARRAY_RANGE_REF)
972 pp_string (buffer, " ...");
973 pp_character (buffer, ']');
974
975 op0 = array_ref_low_bound (node);
976 op1 = array_ref_element_size (node);
977
978 if (!integer_zerop (op0)
979 || TREE_OPERAND (node, 2)
980 || TREE_OPERAND (node, 3))
981 {
982 pp_string (buffer, "{lb: ");
983 dump_generic_node (buffer, op0, spc, flags, false);
984 pp_string (buffer, " sz: ");
985 dump_generic_node (buffer, op1, spc, flags, false);
986 pp_character (buffer, '}');
987 }
988 break;
989
990 case CONSTRUCTOR:
991 {
992 unsigned HOST_WIDE_INT ix;
993 tree field, val;
994 bool is_struct_init = FALSE;
995 pp_character (buffer, '{');
996 if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
997 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
998 is_struct_init = TRUE;
999 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
1000 {
1001 if (field && is_struct_init)
1002 {
1003 pp_character (buffer, '.');
1004 dump_generic_node (buffer, field, spc, flags, false);
1005 pp_string (buffer, "=");
1006 }
1007 if (val && TREE_CODE (val) == ADDR_EXPR)
1008 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
1009 val = TREE_OPERAND (val, 0);
1010 if (val && TREE_CODE (val) == FUNCTION_DECL)
1011 dump_decl_name (buffer, val, flags);
1012 else
1013 dump_generic_node (buffer, val, spc, flags, false);
1014 if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
1015 {
1016 pp_character (buffer, ',');
1017 pp_space (buffer);
1018 }
1019 }
1020 pp_character (buffer, '}');
1021 }
1022 break;
1023
1024 case COMPOUND_EXPR:
1025 {
1026 tree *tp;
1027 if (flags & TDF_SLIM)
1028 {
1029 pp_string (buffer, "<COMPOUND_EXPR>");
1030 break;
1031 }
1032
1033 dump_generic_node (buffer, TREE_OPERAND (node, 0),
1034 spc, flags, !(flags & TDF_SLIM));
1035 if (flags & TDF_SLIM)
1036 newline_and_indent (buffer, spc);
1037 else
1038 {
1039 pp_character (buffer, ',');
1040 pp_space (buffer);
1041 }
1042
1043 for (tp = &TREE_OPERAND (node, 1);
1044 TREE_CODE (*tp) == COMPOUND_EXPR;
1045 tp = &TREE_OPERAND (*tp, 1))
1046 {
1047 dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
1048 spc, flags, !(flags & TDF_SLIM));
1049 if (flags & TDF_SLIM)
1050 newline_and_indent (buffer, spc);
1051 else
1052 {
1053 pp_character (buffer, ',');
1054 pp_space (buffer);
1055 }
1056 }
1057
1058 dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
1059 }
1060 break;
1061
1062 case STATEMENT_LIST:
1063 {
1064 tree_stmt_iterator si;
1065 bool first = true;
1066
1067 if (flags & TDF_SLIM)
1068 {
1069 pp_string (buffer, "<STATEMENT_LIST>");
1070 break;
1071 }
1072
1073 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1074 {
1075 if (!first)
1076 newline_and_indent (buffer, spc);
1077 else
1078 first = false;
1079 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
1080 }
1081 }
1082 break;
1083
1084 case MODIFY_EXPR:
1085 case GIMPLE_MODIFY_STMT:
1086 case INIT_EXPR:
1087 dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 0), spc, flags,
1088 false);
1089 pp_space (buffer);
1090 pp_character (buffer, '=');
1091 if (TREE_CODE (node) == GIMPLE_MODIFY_STMT
1092 && MOVE_NONTEMPORAL (node))
1093 pp_string (buffer, "{nt}");
1094 if (TREE_CODE (node) == GIMPLE_MODIFY_STMT)
1095 {
1096 stmt_ann_t ann;
1097 if ((ann = stmt_ann (node))
1098 && ann->has_volatile_ops)
1099 pp_string (buffer, "{v}");
1100 }
1101 pp_space (buffer);
1102 dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
1103 false);
1104 break;
1105
1106 case TARGET_EXPR:
1107 pp_string (buffer, "TARGET_EXPR <");
1108 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1109 pp_character (buffer, ',');
1110 pp_space (buffer);
1111 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
1112 pp_character (buffer, '>');
1113 break;
1114
1115 case DECL_EXPR:
1116 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1117 is_stmt = false;
1118 break;
1119
1120 case COND_EXPR:
1121 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1122 {
1123 pp_string (buffer, "if (");
1124 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1125 pp_character (buffer, ')');
1126 /* The lowered cond_exprs should always be printed in full. */
1127 if (COND_EXPR_THEN (node)
1128 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1129 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1130 && COND_EXPR_ELSE (node)
1131 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1132 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1133 {
1134 pp_space (buffer);
1135 dump_generic_node (buffer, COND_EXPR_THEN (node),
1136 0, flags, true);
1137 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1138 {
1139 pp_string (buffer, " else ");
1140 dump_generic_node (buffer, COND_EXPR_ELSE (node),
1141 0, flags, true);
1142 }
1143 }
1144 else if (!(flags & TDF_SLIM))
1145 {
1146 /* Output COND_EXPR_THEN. */
1147 if (COND_EXPR_THEN (node))
1148 {
1149 newline_and_indent (buffer, spc+2);
1150 pp_character (buffer, '{');
1151 newline_and_indent (buffer, spc+4);
1152 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1153 flags, true);
1154 newline_and_indent (buffer, spc+2);
1155 pp_character (buffer, '}');
1156 }
1157
1158 /* Output COND_EXPR_ELSE. */
1159 if (COND_EXPR_ELSE (node)
1160 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1161 {
1162 newline_and_indent (buffer, spc);
1163 pp_string (buffer, "else");
1164 newline_and_indent (buffer, spc+2);
1165 pp_character (buffer, '{');
1166 newline_and_indent (buffer, spc+4);
1167 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1168 flags, true);
1169 newline_and_indent (buffer, spc+2);
1170 pp_character (buffer, '}');
1171 }
1172 }
1173 is_expr = false;
1174 }
1175 else
1176 {
1177 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1178 pp_space (buffer);
1179 pp_character (buffer, '?');
1180 pp_space (buffer);
1181 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1182 pp_space (buffer);
1183 pp_character (buffer, ':');
1184 pp_space (buffer);
1185 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1186 }
1187 break;
1188
1189 case BIND_EXPR:
1190 pp_character (buffer, '{');
1191 if (!(flags & TDF_SLIM))
1192 {
1193 if (BIND_EXPR_VARS (node))
1194 {
1195 pp_newline (buffer);
1196
1197 for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
1198 {
1199 print_declaration (buffer, op0, spc+2, flags);
1200 pp_newline (buffer);
1201 }
1202 }
1203
1204 newline_and_indent (buffer, spc+2);
1205 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1206 newline_and_indent (buffer, spc);
1207 pp_character (buffer, '}');
1208 }
1209 is_expr = false;
1210 break;
1211
1212 case CALL_EXPR:
1213 print_call_name (buffer, node);
1214
1215 /* Print parameters. */
1216 pp_space (buffer);
1217 pp_character (buffer, '(');
1218 {
1219 tree arg;
1220 call_expr_arg_iterator iter;
1221 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
1222 {
1223 dump_generic_node (buffer, arg, spc, flags, false);
1224 if (more_call_expr_args_p (&iter))
1225 {
1226 pp_character (buffer, ',');
1227 pp_space (buffer);
1228 }
1229 }
1230 }
1231 if (CALL_EXPR_VA_ARG_PACK (node))
1232 {
1233 if (call_expr_nargs (node) > 0)
1234 {
1235 pp_character (buffer, ',');
1236 pp_space (buffer);
1237 }
1238 pp_string (buffer, "__builtin_va_arg_pack ()");
1239 }
1240 pp_character (buffer, ')');
1241
1242 op1 = CALL_EXPR_STATIC_CHAIN (node);
1243 if (op1)
1244 {
1245 pp_string (buffer, " [static-chain: ");
1246 dump_generic_node (buffer, op1, spc, flags, false);
1247 pp_character (buffer, ']');
1248 }
1249
1250 if (CALL_EXPR_RETURN_SLOT_OPT (node))
1251 pp_string (buffer, " [return slot optimization]");
1252 if (CALL_EXPR_TAILCALL (node))
1253 pp_string (buffer, " [tail call]");
1254 break;
1255
1256 case WITH_CLEANUP_EXPR:
1257 NIY;
1258 break;
1259
1260 case CLEANUP_POINT_EXPR:
1261 pp_string (buffer, "<<cleanup_point ");
1262 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1263 pp_string (buffer, ">>");
1264 break;
1265
1266 case PLACEHOLDER_EXPR:
1267 pp_string (buffer, "<PLACEHOLDER_EXPR ");
1268 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1269 pp_character (buffer, '>');
1270 break;
1271
1272 /* Binary arithmetic and logic expressions. */
1273 case WIDEN_SUM_EXPR:
1274 case WIDEN_MULT_EXPR:
1275 case MULT_EXPR:
1276 case PLUS_EXPR:
1277 case POINTER_PLUS_EXPR:
1278 case MINUS_EXPR:
1279 case TRUNC_DIV_EXPR:
1280 case CEIL_DIV_EXPR:
1281 case FLOOR_DIV_EXPR:
1282 case ROUND_DIV_EXPR:
1283 case TRUNC_MOD_EXPR:
1284 case CEIL_MOD_EXPR:
1285 case FLOOR_MOD_EXPR:
1286 case ROUND_MOD_EXPR:
1287 case RDIV_EXPR:
1288 case EXACT_DIV_EXPR:
1289 case LSHIFT_EXPR:
1290 case RSHIFT_EXPR:
1291 case LROTATE_EXPR:
1292 case RROTATE_EXPR:
1293 case VEC_LSHIFT_EXPR:
1294 case VEC_RSHIFT_EXPR:
1295 case BIT_IOR_EXPR:
1296 case BIT_XOR_EXPR:
1297 case BIT_AND_EXPR:
1298 case TRUTH_ANDIF_EXPR:
1299 case TRUTH_ORIF_EXPR:
1300 case TRUTH_AND_EXPR:
1301 case TRUTH_OR_EXPR:
1302 case TRUTH_XOR_EXPR:
1303 case LT_EXPR:
1304 case LE_EXPR:
1305 case GT_EXPR:
1306 case GE_EXPR:
1307 case EQ_EXPR:
1308 case NE_EXPR:
1309 case UNLT_EXPR:
1310 case UNLE_EXPR:
1311 case UNGT_EXPR:
1312 case UNGE_EXPR:
1313 case UNEQ_EXPR:
1314 case LTGT_EXPR:
1315 case ORDERED_EXPR:
1316 case UNORDERED_EXPR:
1317 {
1318 const char *op = op_symbol (node);
1319 op0 = TREE_OPERAND (node, 0);
1320 op1 = TREE_OPERAND (node, 1);
1321
1322 /* When the operands are expressions with less priority,
1323 keep semantics of the tree representation. */
1324 if (op_prio (op0) <= op_prio (node))
1325 {
1326 pp_character (buffer, '(');
1327 dump_generic_node (buffer, op0, spc, flags, false);
1328 pp_character (buffer, ')');
1329 }
1330 else
1331 dump_generic_node (buffer, op0, spc, flags, false);
1332
1333 pp_space (buffer);
1334 pp_string (buffer, op);
1335 pp_space (buffer);
1336
1337 /* When the operands are expressions with less priority,
1338 keep semantics of the tree representation. */
1339 if (op_prio (op1) <= op_prio (node))
1340 {
1341 pp_character (buffer, '(');
1342 dump_generic_node (buffer, op1, spc, flags, false);
1343 pp_character (buffer, ')');
1344 }
1345 else
1346 dump_generic_node (buffer, op1, spc, flags, false);
1347 }
1348 break;
1349
1350 /* Unary arithmetic and logic expressions. */
1351 case NEGATE_EXPR:
1352 case BIT_NOT_EXPR:
1353 case TRUTH_NOT_EXPR:
1354 case ADDR_EXPR:
1355 case PREDECREMENT_EXPR:
1356 case PREINCREMENT_EXPR:
1357 case ALIGN_INDIRECT_REF:
1358 case MISALIGNED_INDIRECT_REF:
1359 case INDIRECT_REF:
1360 if (TREE_CODE (node) == ADDR_EXPR
1361 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1362 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1363 ; /* Do not output '&' for strings and function pointers. */
1364 else
1365 pp_string (buffer, op_symbol (node));
1366
1367 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1368 {
1369 pp_character (buffer, '(');
1370 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1371 pp_character (buffer, ')');
1372 }
1373 else
1374 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1375
1376 if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1377 {
1378 pp_string (buffer, "{misalignment: ");
1379 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1380 pp_character (buffer, '}');
1381 }
1382 break;
1383
1384 case POSTDECREMENT_EXPR:
1385 case POSTINCREMENT_EXPR:
1386 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1387 {
1388 pp_character (buffer, '(');
1389 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1390 pp_character (buffer, ')');
1391 }
1392 else
1393 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1394 pp_string (buffer, op_symbol (node));
1395 break;
1396
1397 case MIN_EXPR:
1398 pp_string (buffer, "MIN_EXPR <");
1399 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1400 pp_string (buffer, ", ");
1401 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1402 pp_character (buffer, '>');
1403 break;
1404
1405 case MAX_EXPR:
1406 pp_string (buffer, "MAX_EXPR <");
1407 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1408 pp_string (buffer, ", ");
1409 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1410 pp_character (buffer, '>');
1411 break;
1412
1413 case ABS_EXPR:
1414 pp_string (buffer, "ABS_EXPR <");
1415 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1416 pp_character (buffer, '>');
1417 break;
1418
1419 case RANGE_EXPR:
1420 NIY;
1421 break;
1422
1423 case FIXED_CONVERT_EXPR:
1424 case FIX_TRUNC_EXPR:
1425 case FLOAT_EXPR:
1426 case CONVERT_EXPR:
1427 case NOP_EXPR:
1428 type = TREE_TYPE (node);
1429 op0 = TREE_OPERAND (node, 0);
1430 if (type != TREE_TYPE (op0))
1431 {
1432 pp_character (buffer, '(');
1433 dump_generic_node (buffer, type, spc, flags, false);
1434 pp_string (buffer, ") ");
1435 }
1436 if (op_prio (op0) < op_prio (node))
1437 pp_character (buffer, '(');
1438 dump_generic_node (buffer, op0, spc, flags, false);
1439 if (op_prio (op0) < op_prio (node))
1440 pp_character (buffer, ')');
1441 break;
1442
1443 case VIEW_CONVERT_EXPR:
1444 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1445 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1446 pp_string (buffer, ">(");
1447 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1448 pp_character (buffer, ')');
1449 break;
1450
1451 case PAREN_EXPR:
1452 pp_string (buffer, "((");
1453 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1454 pp_string (buffer, "))");
1455 break;
1456
1457 case NON_LVALUE_EXPR:
1458 pp_string (buffer, "NON_LVALUE_EXPR <");
1459 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1460 pp_character (buffer, '>');
1461 break;
1462
1463 case SAVE_EXPR:
1464 pp_string (buffer, "SAVE_EXPR <");
1465 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1466 pp_character (buffer, '>');
1467 break;
1468
1469 case COMPLEX_EXPR:
1470 pp_string (buffer, "COMPLEX_EXPR <");
1471 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1472 pp_string (buffer, ", ");
1473 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1474 pp_string (buffer, ">");
1475 break;
1476
1477 case CONJ_EXPR:
1478 pp_string (buffer, "CONJ_EXPR <");
1479 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1480 pp_string (buffer, ">");
1481 break;
1482
1483 case REALPART_EXPR:
1484 pp_string (buffer, "REALPART_EXPR <");
1485 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1486 pp_string (buffer, ">");
1487 break;
1488
1489 case IMAGPART_EXPR:
1490 pp_string (buffer, "IMAGPART_EXPR <");
1491 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1492 pp_string (buffer, ">");
1493 break;
1494
1495 case VA_ARG_EXPR:
1496 pp_string (buffer, "VA_ARG_EXPR <");
1497 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1498 pp_string (buffer, ">");
1499 break;
1500
1501 case TRY_FINALLY_EXPR:
1502 case TRY_CATCH_EXPR:
1503 pp_string (buffer, "try");
1504 newline_and_indent (buffer, spc+2);
1505 pp_string (buffer, "{");
1506 newline_and_indent (buffer, spc+4);
1507 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1508 newline_and_indent (buffer, spc+2);
1509 pp_string (buffer, "}");
1510 newline_and_indent (buffer, spc);
1511 pp_string (buffer,
1512 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1513 newline_and_indent (buffer, spc+2);
1514 pp_string (buffer, "{");
1515 newline_and_indent (buffer, spc+4);
1516 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1517 newline_and_indent (buffer, spc+2);
1518 pp_string (buffer, "}");
1519 is_expr = false;
1520 break;
1521
1522 case CATCH_EXPR:
1523 pp_string (buffer, "catch (");
1524 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1525 pp_string (buffer, ")");
1526 newline_and_indent (buffer, spc+2);
1527 pp_string (buffer, "{");
1528 newline_and_indent (buffer, spc+4);
1529 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1530 newline_and_indent (buffer, spc+2);
1531 pp_string (buffer, "}");
1532 is_expr = false;
1533 break;
1534
1535 case EH_FILTER_EXPR:
1536 pp_string (buffer, "<<<eh_filter (");
1537 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1538 pp_string (buffer, ")>>>");
1539 newline_and_indent (buffer, spc+2);
1540 pp_string (buffer, "{");
1541 newline_and_indent (buffer, spc+4);
1542 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1543 newline_and_indent (buffer, spc+2);
1544 pp_string (buffer, "}");
1545 is_expr = false;
1546 break;
1547
1548 case CHANGE_DYNAMIC_TYPE_EXPR:
1549 pp_string (buffer, "<<<change_dynamic_type (");
1550 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_NEW_TYPE (node), spc + 2,
1551 flags, false);
1552 pp_string (buffer, ") ");
1553 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_LOCATION (node), spc + 2,
1554 flags, false);
1555 pp_string (buffer, ")>>>");
1556 is_expr = false;
1557 break;
1558
1559 case LABEL_EXPR:
1560 op0 = TREE_OPERAND (node, 0);
1561 /* If this is for break or continue, don't bother printing it. */
1562 if (DECL_NAME (op0))
1563 {
1564 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1565 if (strcmp (name, "break") == 0
1566 || strcmp (name, "continue") == 0)
1567 break;
1568 }
1569 dump_generic_node (buffer, op0, spc, flags, false);
1570 pp_character (buffer, ':');
1571 if (DECL_NONLOCAL (op0))
1572 pp_string (buffer, " [non-local]");
1573 break;
1574
1575 case EXC_PTR_EXPR:
1576 pp_string (buffer, "<<<exception object>>>");
1577 break;
1578
1579 case FILTER_EXPR:
1580 pp_string (buffer, "<<<filter object>>>");
1581 break;
1582
1583 case LOOP_EXPR:
1584 pp_string (buffer, "while (1)");
1585 if (!(flags & TDF_SLIM))
1586 {
1587 newline_and_indent (buffer, spc+2);
1588 pp_character (buffer, '{');
1589 newline_and_indent (buffer, spc+4);
1590 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1591 newline_and_indent (buffer, spc+2);
1592 pp_character (buffer, '}');
1593 }
1594 is_expr = false;
1595 break;
1596
1597 case PREDICT_EXPR:
1598 pp_string (buffer, "// predicted ");
1599 if (PREDICT_EXPR_OUTCOME (node))
1600 pp_string (buffer, "likely by ");
1601 else
1602 pp_string (buffer, "unlikely by ");
1603 pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
1604 pp_string (buffer, " predictor.");
1605 break;
1606
1607 case RETURN_EXPR:
1608 pp_string (buffer, "return");
1609 op0 = TREE_OPERAND (node, 0);
1610 if (op0)
1611 {
1612 pp_space (buffer);
1613 if (TREE_CODE (op0) == MODIFY_EXPR
1614 || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
1615 dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
1616 spc, flags, false);
1617 else
1618 dump_generic_node (buffer, op0, spc, flags, false);
1619 }
1620 break;
1621
1622 case EXIT_EXPR:
1623 pp_string (buffer, "if (");
1624 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1625 pp_string (buffer, ") break");
1626 break;
1627
1628 case SWITCH_EXPR:
1629 pp_string (buffer, "switch (");
1630 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1631 pp_character (buffer, ')');
1632 if (!(flags & TDF_SLIM))
1633 {
1634 newline_and_indent (buffer, spc+2);
1635 pp_character (buffer, '{');
1636 if (SWITCH_BODY (node))
1637 {
1638 newline_and_indent (buffer, spc+4);
1639 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1640 true);
1641 }
1642 else
1643 {
1644 tree vec = SWITCH_LABELS (node);
1645 size_t i, n = TREE_VEC_LENGTH (vec);
1646 for (i = 0; i < n; ++i)
1647 {
1648 tree elt = TREE_VEC_ELT (vec, i);
1649 newline_and_indent (buffer, spc+4);
1650 if (elt)
1651 {
1652 dump_generic_node (buffer, elt, spc+4, flags, false);
1653 pp_string (buffer, " goto ");
1654 dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1655 flags, true);
1656 pp_semicolon (buffer);
1657 }
1658 else
1659 pp_string (buffer, "case ???: goto ???;");
1660 }
1661 }
1662 newline_and_indent (buffer, spc+2);
1663 pp_character (buffer, '}');
1664 }
1665 is_expr = false;
1666 break;
1667
1668 case GOTO_EXPR:
1669 op0 = GOTO_DESTINATION (node);
1670 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1671 {
1672 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1673 if (strcmp (name, "break") == 0
1674 || strcmp (name, "continue") == 0)
1675 {
1676 pp_string (buffer, name);
1677 break;
1678 }
1679 }
1680 pp_string (buffer, "goto ");
1681 dump_generic_node (buffer, op0, spc, flags, false);
1682 break;
1683
1684 case RESX_EXPR:
1685 pp_string (buffer, "resx ");
1686 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1687 break;
1688
1689 case ASM_EXPR:
1690 pp_string (buffer, "__asm__");
1691 if (ASM_VOLATILE_P (node))
1692 pp_string (buffer, " __volatile__");
1693 pp_character (buffer, '(');
1694 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1695 pp_character (buffer, ':');
1696 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1697 pp_character (buffer, ':');
1698 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1699 if (ASM_CLOBBERS (node))
1700 {
1701 pp_character (buffer, ':');
1702 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1703 }
1704 pp_string (buffer, ")");
1705 break;
1706
1707 case CASE_LABEL_EXPR:
1708 if (CASE_LOW (node) && CASE_HIGH (node))
1709 {
1710 pp_string (buffer, "case ");
1711 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1712 pp_string (buffer, " ... ");
1713 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1714 }
1715 else if (CASE_LOW (node))
1716 {
1717 pp_string (buffer, "case ");
1718 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1719 }
1720 else
1721 pp_string (buffer, "default ");
1722 pp_character (buffer, ':');
1723 break;
1724
1725 case OBJ_TYPE_REF:
1726 pp_string (buffer, "OBJ_TYPE_REF(");
1727 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1728 pp_character (buffer, ';');
1729 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1730 pp_character (buffer, '-');
1731 pp_character (buffer, '>');
1732 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1733 pp_character (buffer, ')');
1734 break;
1735
1736 case PHI_NODE:
1737 {
1738 int i;
1739
1740 dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1741 pp_string (buffer, " = PHI <");
1742 for (i = 0; i < PHI_NUM_ARGS (node); i++)
1743 {
1744 dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1745 pp_string (buffer, "(");
1746 pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1747 pp_string (buffer, ")");
1748 if (i < PHI_NUM_ARGS (node) - 1)
1749 pp_string (buffer, ", ");
1750 }
1751 pp_string (buffer, ">");
1752
1753 if (stmt_references_memory_p (node) && (flags & TDF_MEMSYMS))
1754 dump_symbols (buffer, STORED_SYMS (node), flags);
1755 }
1756 break;
1757
1758 case SSA_NAME:
1759 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1760 pp_string (buffer, "_");
1761 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1762 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1763 pp_string (buffer, "(ab)");
1764 else if (SSA_NAME_IS_DEFAULT_DEF (node))
1765 pp_string (buffer, "(D)");
1766 break;
1767
1768 case WITH_SIZE_EXPR:
1769 pp_string (buffer, "WITH_SIZE_EXPR <");
1770 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1771 pp_string (buffer, ", ");
1772 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1773 pp_string (buffer, ">");
1774 break;
1775
1776 case VALUE_HANDLE:
1777 pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1778 break;
1779
1780 case ASSERT_EXPR:
1781 pp_string (buffer, "ASSERT_EXPR <");
1782 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1783 pp_string (buffer, ", ");
1784 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1785 pp_string (buffer, ">");
1786 break;
1787
1788 case SCEV_KNOWN:
1789 pp_string (buffer, "scev_known");
1790 break;
1791
1792 case SCEV_NOT_KNOWN:
1793 pp_string (buffer, "scev_not_known");
1794 break;
1795
1796 case POLYNOMIAL_CHREC:
1797 pp_string (buffer, "{");
1798 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1799 pp_string (buffer, ", +, ");
1800 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1801 pp_string (buffer, "}_");
1802 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1803 is_stmt = false;
1804 break;
1805
1806 case REALIGN_LOAD_EXPR:
1807 pp_string (buffer, "REALIGN_LOAD <");
1808 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1809 pp_string (buffer, ", ");
1810 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1811 pp_string (buffer, ", ");
1812 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1813 pp_string (buffer, ">");
1814 break;
1815
1816 case VEC_COND_EXPR:
1817 pp_string (buffer, " VEC_COND_EXPR < ");
1818 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1819 pp_string (buffer, " , ");
1820 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1821 pp_string (buffer, " , ");
1822 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1823 pp_string (buffer, " > ");
1824 break;
1825
1826 case DOT_PROD_EXPR:
1827 pp_string (buffer, " DOT_PROD_EXPR < ");
1828 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1829 pp_string (buffer, ", ");
1830 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1831 pp_string (buffer, ", ");
1832 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1833 pp_string (buffer, " > ");
1834 break;
1835
1836 case OMP_PARALLEL:
1837 pp_string (buffer, "#pragma omp parallel");
1838 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
1839 if (OMP_PARALLEL_FN (node))
1840 {
1841 pp_string (buffer, " [child fn: ");
1842 dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);
1843
1844 pp_string (buffer, " (");
1845
1846 if (OMP_PARALLEL_DATA_ARG (node))
1847 dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,
1848 false);
1849 else
1850 pp_string (buffer, "???");
1851
1852 pp_string (buffer, ")]");
1853 }
1854
1855 dump_omp_body:
1856 if (!(flags & TDF_SLIM) && OMP_BODY (node))
1857 {
1858 newline_and_indent (buffer, spc + 2);
1859 pp_character (buffer, '{');
1860 newline_and_indent (buffer, spc + 4);
1861 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
1862 newline_and_indent (buffer, spc + 2);
1863 pp_character (buffer, '}');
1864 }
1865 is_expr = false;
1866 break;
1867
1868 case OMP_FOR:
1869 pp_string (buffer, "#pragma omp for");
1870 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
1871
1872 if (!(flags & TDF_SLIM))
1873 {
1874 if (OMP_FOR_PRE_BODY (node))
1875 {
1876 newline_and_indent (buffer, spc + 2);
1877 pp_character (buffer, '{');
1878 spc += 4;
1879 newline_and_indent (buffer, spc);
1880 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
1881 spc, flags, false);
1882 }
1883 newline_and_indent (buffer, spc);
1884 pp_string (buffer, "for (");
1885 dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);
1886 pp_string (buffer, "; ");
1887 dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);
1888 pp_string (buffer, "; ");
1889 dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);
1890 pp_string (buffer, ")");
1891 if (OMP_FOR_BODY (node))
1892 {
1893 newline_and_indent (buffer, spc + 2);
1894 pp_character (buffer, '{');
1895 newline_and_indent (buffer, spc + 4);
1896 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
1897 false);
1898 newline_and_indent (buffer, spc + 2);
1899 pp_character (buffer, '}');
1900 }
1901 if (OMP_FOR_PRE_BODY (node))
1902 {
1903 spc -= 4;
1904 newline_and_indent (buffer, spc + 2);
1905 pp_character (buffer, '}');
1906 }
1907 }
1908 is_expr = false;
1909 break;
1910
1911 case OMP_SECTIONS:
1912 pp_string (buffer, "#pragma omp sections");
1913 if (OMP_SECTIONS_CONTROL (node))
1914 {
1915 pp_string (buffer, " <");
1916 dump_generic_node (buffer, OMP_SECTIONS_CONTROL (node), spc,
1917 flags, false);
1918 pp_string (buffer, ">");
1919 }
1920 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
1921 goto dump_omp_body;
1922
1923 case OMP_SECTIONS_SWITCH:
1924 pp_string (buffer, "OMP_SECTIONS_SWITCH");
1925 is_expr = false;
1926 break;
1927
1928 case OMP_SECTION:
1929 pp_string (buffer, "#pragma omp section");
1930 goto dump_omp_body;
1931
1932 case OMP_MASTER:
1933 pp_string (buffer, "#pragma omp master");
1934 goto dump_omp_body;
1935
1936 case OMP_ORDERED:
1937 pp_string (buffer, "#pragma omp ordered");
1938 goto dump_omp_body;
1939
1940 case OMP_CRITICAL:
1941 pp_string (buffer, "#pragma omp critical");
1942 if (OMP_CRITICAL_NAME (node))
1943 {
1944 pp_space (buffer);
1945 pp_character (buffer, '(');
1946 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
1947 flags, false);
1948 pp_character (buffer, ')');
1949 }
1950 goto dump_omp_body;
1951
1952 case OMP_ATOMIC:
1953 pp_string (buffer, "#pragma omp atomic");
1954 newline_and_indent (buffer, spc + 2);
1955 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1956 pp_space (buffer);
1957 pp_character (buffer, '=');
1958 pp_space (buffer);
1959 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1960 break;
1961
1962 case OMP_ATOMIC_LOAD:
1963 pp_string (buffer, "#pragma omp atomic_load");
1964 newline_and_indent (buffer, spc + 2);
1965 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1966 pp_space (buffer);
1967 pp_character (buffer, '=');
1968 pp_space (buffer);
1969 pp_character (buffer, '*');
1970 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1971 break;
1972
1973 case OMP_ATOMIC_STORE:
1974 pp_string (buffer, "#pragma omp atomic_store (");
1975 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1976 pp_character (buffer, ')');
1977 break;
1978
1979 case OMP_SINGLE:
1980 pp_string (buffer, "#pragma omp single");
1981 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
1982 goto dump_omp_body;
1983
1984 case OMP_RETURN:
1985 pp_string (buffer, "OMP_RETURN");
1986 if (OMP_RETURN_NOWAIT (node))
1987 pp_string (buffer, " [nowait]");
1988 is_expr = false;
1989 break;
1990
1991 case OMP_CONTINUE:
1992 pp_string (buffer, "OMP_CONTINUE <");
1993 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1994 pp_string (buffer, " <- ");
1995 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1996 pp_string (buffer, ">");
1997 is_expr = false;
1998 break;
1999
2000 case OMP_CLAUSE:
2001 dump_omp_clause (buffer, node, spc, flags);
2002 is_expr = false;
2003 break;
2004
2005 case REDUC_MAX_EXPR:
2006 pp_string (buffer, " REDUC_MAX_EXPR < ");
2007 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2008 pp_string (buffer, " > ");
2009 break;
2010
2011 case REDUC_MIN_EXPR:
2012 pp_string (buffer, " REDUC_MIN_EXPR < ");
2013 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2014 pp_string (buffer, " > ");
2015 break;
2016
2017 case REDUC_PLUS_EXPR:
2018 pp_string (buffer, " REDUC_PLUS_EXPR < ");
2019 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2020 pp_string (buffer, " > ");
2021 break;
2022
2023 case VEC_WIDEN_MULT_HI_EXPR:
2024 pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
2025 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2026 pp_string (buffer, ", ");
2027 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2028 pp_string (buffer, " > ");
2029 break;
2030
2031 case VEC_WIDEN_MULT_LO_EXPR:
2032 pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
2033 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2034 pp_string (buffer, ", ");
2035 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2036 pp_string (buffer, " > ");
2037 break;
2038
2039 case VEC_UNPACK_HI_EXPR:
2040 pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
2041 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2042 pp_string (buffer, " > ");
2043 break;
2044
2045 case VEC_UNPACK_LO_EXPR:
2046 pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
2047 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2048 pp_string (buffer, " > ");
2049 break;
2050
2051 case VEC_UNPACK_FLOAT_HI_EXPR:
2052 pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2053 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2054 pp_string (buffer, " > ");
2055 break;
2056
2057 case VEC_UNPACK_FLOAT_LO_EXPR:
2058 pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2059 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2060 pp_string (buffer, " > ");
2061 break;
2062
2063 case VEC_PACK_TRUNC_EXPR:
2064 pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
2065 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2066 pp_string (buffer, ", ");
2067 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2068 pp_string (buffer, " > ");
2069 break;
2070
2071 case VEC_PACK_SAT_EXPR:
2072 pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
2073 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2074 pp_string (buffer, ", ");
2075 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2076 pp_string (buffer, " > ");
2077 break;
2078
2079 case VEC_PACK_FIX_TRUNC_EXPR:
2080 pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");
2081 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2082 pp_string (buffer, ", ");
2083 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2084 pp_string (buffer, " > ");
2085 break;
2086
2087 case BLOCK:
2088 {
2089 tree t;
2090 pp_string (buffer, "BLOCK");
2091
2092 if (BLOCK_ABSTRACT (node))
2093 pp_string (buffer, " [abstract]");
2094
2095 if (TREE_ASM_WRITTEN (node))
2096 pp_string (buffer, " [written]");
2097
2098 newline_and_indent (buffer, spc + 2);
2099
2100 if (BLOCK_SUPERCONTEXT (node))
2101 {
2102 pp_string (buffer, "SUPERCONTEXT: ");
2103 if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
2104 pp_printf (buffer, "BLOCK %p",
2105 (void *)BLOCK_SUPERCONTEXT (node));
2106 else
2107 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
2108 false);
2109 newline_and_indent (buffer, spc + 2);
2110 }
2111
2112 if (BLOCK_SUBBLOCKS (node))
2113 {
2114 pp_string (buffer, "SUBBLOCKS: ");
2115 for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
2116 pp_printf (buffer, "%p ", (void *)t);
2117 newline_and_indent (buffer, spc + 2);
2118 }
2119
2120 if (BLOCK_VARS (node))
2121 {
2122 pp_string (buffer, "VARS: ");
2123 for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
2124 {
2125 dump_generic_node (buffer, t, 0, flags, false);
2126 pp_string (buffer, " ");
2127 }
2128 newline_and_indent (buffer, spc + 2);
2129 }
2130
2131 if (BLOCK_ABSTRACT_ORIGIN (node))
2132 {
2133 pp_string (buffer, "ABSTRACT_ORIGIN: ");
2134 if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
2135 pp_printf (buffer, "BLOCK %p",
2136 (void *)BLOCK_ABSTRACT_ORIGIN (node));
2137 else
2138 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
2139 false);
2140 newline_and_indent (buffer, spc + 2);
2141 }
2142 }
2143 break;
2144
2145 case VEC_EXTRACT_EVEN_EXPR:
2146 pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
2147 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2148 pp_string (buffer, ", ");
2149 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2150 pp_string (buffer, " > ");
2151 break;
2152
2153 case VEC_EXTRACT_ODD_EXPR:
2154 pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
2155 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2156 pp_string (buffer, ", ");
2157 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2158 pp_string (buffer, " > ");
2159 break;
2160
2161 case VEC_INTERLEAVE_HIGH_EXPR:
2162 pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
2163 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2164 pp_string (buffer, ", ");
2165 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2166 pp_string (buffer, " > ");
2167 break;
2168
2169 case VEC_INTERLEAVE_LOW_EXPR:
2170 pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
2171 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2172 pp_string (buffer, ", ");
2173 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2174 pp_string (buffer, " > ");
2175 break;
2176
2177 default:
2178 NIY;
2179 }
2180
2181 if (is_stmt && is_expr)
2182 pp_semicolon (buffer);
2183
2184 /* If we're building a diagnostic, the formatted text will be written
2185 into BUFFER's stream by the caller; otherwise, write it now. */
2186 if (!(flags & TDF_DIAGNOSTIC))
2187 pp_write_text_to_stream (buffer);
2188
2189 return spc;
2190 }
2191
2192 /* Print the declaration of a variable. */
2193
2194 static void
2195 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2196 {
2197 INDENT (spc);
2198
2199 if (TREE_CODE (t) == TYPE_DECL)
2200 pp_string (buffer, "typedef ");
2201
2202 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2203 pp_string (buffer, "register ");
2204
2205 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2206 pp_string (buffer, "extern ");
2207 else if (TREE_STATIC (t))
2208 pp_string (buffer, "static ");
2209
2210 /* Print the type and name. */
2211 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2212 {
2213 tree tmp;
2214
2215 /* Print array's type. */
2216 tmp = TREE_TYPE (t);
2217 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2218 tmp = TREE_TYPE (tmp);
2219 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2220
2221 /* Print variable's name. */
2222 pp_space (buffer);
2223 dump_generic_node (buffer, t, spc, flags, false);
2224
2225 /* Print the dimensions. */
2226 tmp = TREE_TYPE (t);
2227 while (TREE_CODE (tmp) == ARRAY_TYPE)
2228 {
2229 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
2230 tmp = TREE_TYPE (tmp);
2231 }
2232 }
2233 else if (TREE_CODE (t) == FUNCTION_DECL)
2234 {
2235 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2236 pp_space (buffer);
2237 dump_decl_name (buffer, t, flags);
2238 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2239 }
2240 else
2241 {
2242 /* Print type declaration. */
2243 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2244
2245 /* Print variable's name. */
2246 pp_space (buffer);
2247 dump_generic_node (buffer, t, spc, flags, false);
2248 }
2249
2250 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2251 {
2252 pp_string (buffer, " __asm__ ");
2253 pp_character (buffer, '(');
2254 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2255 pp_character (buffer, ')');
2256 }
2257
2258 /* The initial value of a function serves to determine wether the function
2259 is declared or defined. So the following does not apply to function
2260 nodes. */
2261 if (TREE_CODE (t) != FUNCTION_DECL)
2262 {
2263 /* Print the initial value. */
2264 if (DECL_INITIAL (t))
2265 {
2266 pp_space (buffer);
2267 pp_character (buffer, '=');
2268 pp_space (buffer);
2269 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2270 }
2271 }
2272
2273 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2274 {
2275 pp_string (buffer, " [value-expr: ");
2276 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2277 pp_character (buffer, ']');
2278 }
2279
2280 pp_character (buffer, ';');
2281 }
2282
2283
2284 /* Prints a structure: name, fields, and methods.
2285 FIXME: Still incomplete. */
2286
2287 static void
2288 print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
2289 {
2290 /* Print the name of the structure. */
2291 if (TYPE_NAME (node))
2292 {
2293 INDENT (spc);
2294 if (TREE_CODE (node) == RECORD_TYPE)
2295 pp_string (buffer, "struct ");
2296 else if ((TREE_CODE (node) == UNION_TYPE
2297 || TREE_CODE (node) == QUAL_UNION_TYPE))
2298 pp_string (buffer, "union ");
2299
2300 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2301 }
2302
2303 /* Print the contents of the structure. */
2304 pp_newline (buffer);
2305 INDENT (spc);
2306 pp_character (buffer, '{');
2307 pp_newline (buffer);
2308
2309 /* Print the fields of the structure. */
2310 {
2311 tree tmp;
2312 tmp = TYPE_FIELDS (node);
2313 while (tmp)
2314 {
2315 /* Avoid to print recursively the structure. */
2316 /* FIXME : Not implemented correctly...,
2317 what about the case when we have a cycle in the contain graph? ...
2318 Maybe this could be solved by looking at the scope in which the
2319 structure was declared. */
2320 if (TREE_TYPE (tmp) != node
2321 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
2322 && TREE_TYPE (TREE_TYPE (tmp)) != node))
2323 {
2324 print_declaration (buffer, tmp, spc+2, flags);
2325 pp_newline (buffer);
2326 }
2327 tmp = TREE_CHAIN (tmp);
2328 }
2329 }
2330 INDENT (spc);
2331 pp_character (buffer, '}');
2332 }
2333
2334 /* Return the priority of the operator OP.
2335
2336 From lowest to highest precedence with either left-to-right (L-R)
2337 or right-to-left (R-L) associativity]:
2338
2339 1 [L-R] ,
2340 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2341 3 [R-L] ?:
2342 4 [L-R] ||
2343 5 [L-R] &&
2344 6 [L-R] |
2345 7 [L-R] ^
2346 8 [L-R] &
2347 9 [L-R] == !=
2348 10 [L-R] < <= > >=
2349 11 [L-R] << >>
2350 12 [L-R] + -
2351 13 [L-R] * / %
2352 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2353 15 [L-R] fn() [] -> .
2354
2355 unary +, - and * have higher precedence than the corresponding binary
2356 operators. */
2357
2358 static int
2359 op_prio (const_tree op)
2360 {
2361 if (op == NULL)
2362 return 9999;
2363
2364 switch (TREE_CODE (op))
2365 {
2366 case TREE_LIST:
2367 case COMPOUND_EXPR:
2368 case BIND_EXPR:
2369 return 1;
2370
2371 case MODIFY_EXPR:
2372 case GIMPLE_MODIFY_STMT:
2373 case INIT_EXPR:
2374 return 2;
2375
2376 case COND_EXPR:
2377 return 3;
2378
2379 case TRUTH_OR_EXPR:
2380 case TRUTH_ORIF_EXPR:
2381 return 4;
2382
2383 case TRUTH_AND_EXPR:
2384 case TRUTH_ANDIF_EXPR:
2385 return 5;
2386
2387 case BIT_IOR_EXPR:
2388 return 6;
2389
2390 case BIT_XOR_EXPR:
2391 case TRUTH_XOR_EXPR:
2392 return 7;
2393
2394 case BIT_AND_EXPR:
2395 return 8;
2396
2397 case EQ_EXPR:
2398 case NE_EXPR:
2399 return 9;
2400
2401 case UNLT_EXPR:
2402 case UNLE_EXPR:
2403 case UNGT_EXPR:
2404 case UNGE_EXPR:
2405 case UNEQ_EXPR:
2406 case LTGT_EXPR:
2407 case ORDERED_EXPR:
2408 case UNORDERED_EXPR:
2409 case LT_EXPR:
2410 case LE_EXPR:
2411 case GT_EXPR:
2412 case GE_EXPR:
2413 return 10;
2414
2415 case LSHIFT_EXPR:
2416 case RSHIFT_EXPR:
2417 case LROTATE_EXPR:
2418 case RROTATE_EXPR:
2419 return 11;
2420
2421 case WIDEN_SUM_EXPR:
2422 case PLUS_EXPR:
2423 case POINTER_PLUS_EXPR:
2424 case MINUS_EXPR:
2425 return 12;
2426
2427 case VEC_WIDEN_MULT_HI_EXPR:
2428 case VEC_WIDEN_MULT_LO_EXPR:
2429 case WIDEN_MULT_EXPR:
2430 case DOT_PROD_EXPR:
2431 case MULT_EXPR:
2432 case TRUNC_DIV_EXPR:
2433 case CEIL_DIV_EXPR:
2434 case FLOOR_DIV_EXPR:
2435 case ROUND_DIV_EXPR:
2436 case RDIV_EXPR:
2437 case EXACT_DIV_EXPR:
2438 case TRUNC_MOD_EXPR:
2439 case CEIL_MOD_EXPR:
2440 case FLOOR_MOD_EXPR:
2441 case ROUND_MOD_EXPR:
2442 return 13;
2443
2444 case TRUTH_NOT_EXPR:
2445 case BIT_NOT_EXPR:
2446 case POSTINCREMENT_EXPR:
2447 case POSTDECREMENT_EXPR:
2448 case PREINCREMENT_EXPR:
2449 case PREDECREMENT_EXPR:
2450 case NEGATE_EXPR:
2451 case ALIGN_INDIRECT_REF:
2452 case MISALIGNED_INDIRECT_REF:
2453 case INDIRECT_REF:
2454 case ADDR_EXPR:
2455 case FLOAT_EXPR:
2456 case NOP_EXPR:
2457 case CONVERT_EXPR:
2458 case FIX_TRUNC_EXPR:
2459 case TARGET_EXPR:
2460 return 14;
2461
2462 case CALL_EXPR:
2463 case ARRAY_REF:
2464 case ARRAY_RANGE_REF:
2465 case COMPONENT_REF:
2466 return 15;
2467
2468 /* Special expressions. */
2469 case MIN_EXPR:
2470 case MAX_EXPR:
2471 case ABS_EXPR:
2472 case REALPART_EXPR:
2473 case IMAGPART_EXPR:
2474 case REDUC_MAX_EXPR:
2475 case REDUC_MIN_EXPR:
2476 case REDUC_PLUS_EXPR:
2477 case VEC_LSHIFT_EXPR:
2478 case VEC_RSHIFT_EXPR:
2479 case VEC_UNPACK_HI_EXPR:
2480 case VEC_UNPACK_LO_EXPR:
2481 case VEC_UNPACK_FLOAT_HI_EXPR:
2482 case VEC_UNPACK_FLOAT_LO_EXPR:
2483 case VEC_PACK_TRUNC_EXPR:
2484 case VEC_PACK_SAT_EXPR:
2485 return 16;
2486
2487 case SAVE_EXPR:
2488 case NON_LVALUE_EXPR:
2489 return op_prio (TREE_OPERAND (op, 0));
2490
2491 default:
2492 /* Return an arbitrarily high precedence to avoid surrounding single
2493 VAR_DECLs in ()s. */
2494 return 9999;
2495 }
2496 }
2497
2498
2499 /* Return the symbol associated with operator CODE. */
2500
2501 const char *
2502 op_symbol_code (enum tree_code code)
2503 {
2504 switch (code)
2505 {
2506 case MODIFY_EXPR:
2507 case GIMPLE_MODIFY_STMT:
2508 return "=";
2509
2510 case TRUTH_OR_EXPR:
2511 case TRUTH_ORIF_EXPR:
2512 return "||";
2513
2514 case TRUTH_AND_EXPR:
2515 case TRUTH_ANDIF_EXPR:
2516 return "&&";
2517
2518 case BIT_IOR_EXPR:
2519 return "|";
2520
2521 case TRUTH_XOR_EXPR:
2522 case BIT_XOR_EXPR:
2523 return "^";
2524
2525 case ADDR_EXPR:
2526 case BIT_AND_EXPR:
2527 return "&";
2528
2529 case ORDERED_EXPR:
2530 return "ord";
2531 case UNORDERED_EXPR:
2532 return "unord";
2533
2534 case EQ_EXPR:
2535 return "==";
2536 case UNEQ_EXPR:
2537 return "u==";
2538
2539 case NE_EXPR:
2540 return "!=";
2541
2542 case LT_EXPR:
2543 return "<";
2544 case UNLT_EXPR:
2545 return "u<";
2546
2547 case LE_EXPR:
2548 return "<=";
2549 case UNLE_EXPR:
2550 return "u<=";
2551
2552 case GT_EXPR:
2553 return ">";
2554 case UNGT_EXPR:
2555 return "u>";
2556
2557 case GE_EXPR:
2558 return ">=";
2559 case UNGE_EXPR:
2560 return "u>=";
2561
2562 case LTGT_EXPR:
2563 return "<>";
2564
2565 case LSHIFT_EXPR:
2566 return "<<";
2567
2568 case RSHIFT_EXPR:
2569 return ">>";
2570
2571 case LROTATE_EXPR:
2572 return "r<<";
2573
2574 case RROTATE_EXPR:
2575 return "r>>";
2576
2577 case VEC_LSHIFT_EXPR:
2578 return "v<<";
2579
2580 case VEC_RSHIFT_EXPR:
2581 return "v>>";
2582
2583 case POINTER_PLUS_EXPR:
2584 return "+";
2585
2586 case PLUS_EXPR:
2587 return "+";
2588
2589 case REDUC_PLUS_EXPR:
2590 return "r+";
2591
2592 case WIDEN_SUM_EXPR:
2593 return "w+";
2594
2595 case WIDEN_MULT_EXPR:
2596 return "w*";
2597
2598 case NEGATE_EXPR:
2599 case MINUS_EXPR:
2600 return "-";
2601
2602 case BIT_NOT_EXPR:
2603 return "~";
2604
2605 case TRUTH_NOT_EXPR:
2606 return "!";
2607
2608 case MULT_EXPR:
2609 case INDIRECT_REF:
2610 return "*";
2611
2612 case ALIGN_INDIRECT_REF:
2613 return "A*";
2614
2615 case MISALIGNED_INDIRECT_REF:
2616 return "M*";
2617
2618 case TRUNC_DIV_EXPR:
2619 case RDIV_EXPR:
2620 return "/";
2621
2622 case CEIL_DIV_EXPR:
2623 return "/[cl]";
2624
2625 case FLOOR_DIV_EXPR:
2626 return "/[fl]";
2627
2628 case ROUND_DIV_EXPR:
2629 return "/[rd]";
2630
2631 case EXACT_DIV_EXPR:
2632 return "/[ex]";
2633
2634 case TRUNC_MOD_EXPR:
2635 return "%";
2636
2637 case CEIL_MOD_EXPR:
2638 return "%[cl]";
2639
2640 case FLOOR_MOD_EXPR:
2641 return "%[fl]";
2642
2643 case ROUND_MOD_EXPR:
2644 return "%[rd]";
2645
2646 case PREDECREMENT_EXPR:
2647 return " --";
2648
2649 case PREINCREMENT_EXPR:
2650 return " ++";
2651
2652 case POSTDECREMENT_EXPR:
2653 return "-- ";
2654
2655 case POSTINCREMENT_EXPR:
2656 return "++ ";
2657
2658 case MAX_EXPR:
2659 return "max";
2660
2661 case MIN_EXPR:
2662 return "min";
2663
2664 default:
2665 return "<<< ??? >>>";
2666 }
2667 }
2668
2669 /* Return the symbol associated with operator OP. */
2670
2671 static const char *
2672 op_symbol (const_tree op)
2673 {
2674 return op_symbol_code (TREE_CODE (op));
2675 }
2676
2677 /* Prints the name of a CALL_EXPR. */
2678
2679 static void
2680 print_call_name (pretty_printer *buffer, const_tree node)
2681 {
2682 tree op0;
2683
2684 gcc_assert (TREE_CODE (node) == CALL_EXPR);
2685
2686 op0 = CALL_EXPR_FN (node);
2687
2688 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2689 op0 = TREE_OPERAND (op0, 0);
2690
2691 switch (TREE_CODE (op0))
2692 {
2693 case VAR_DECL:
2694 case PARM_DECL:
2695 dump_function_name (buffer, op0);
2696 break;
2697
2698 case ADDR_EXPR:
2699 case INDIRECT_REF:
2700 case NOP_EXPR:
2701 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2702 break;
2703
2704 case COND_EXPR:
2705 pp_string (buffer, "(");
2706 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2707 pp_string (buffer, ") ? ");
2708 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
2709 pp_string (buffer, " : ");
2710 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
2711 break;
2712
2713 case COMPONENT_REF:
2714 /* The function is a pointer contained in a structure. */
2715 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
2716 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2717 dump_function_name (buffer, TREE_OPERAND (op0, 1));
2718 else
2719 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2720 /* else
2721 We can have several levels of structures and a function
2722 pointer inside. This is not implemented yet... */
2723 /* NIY;*/
2724 break;
2725
2726 case ARRAY_REF:
2727 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2728 dump_function_name (buffer, TREE_OPERAND (op0, 0));
2729 else
2730 dump_generic_node (buffer, op0, 0, 0, false);
2731 break;
2732
2733 case SSA_NAME:
2734 case OBJ_TYPE_REF:
2735 dump_generic_node (buffer, op0, 0, 0, false);
2736 break;
2737
2738 default:
2739 NIY;
2740 }
2741 }
2742
2743 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2744
2745 static void
2746 pretty_print_string (pretty_printer *buffer, const char *str)
2747 {
2748 if (str == NULL)
2749 return;
2750
2751 while (*str)
2752 {
2753 switch (str[0])
2754 {
2755 case '\b':
2756 pp_string (buffer, "\\b");
2757 break;
2758
2759 case '\f':
2760 pp_string (buffer, "\\f");
2761 break;
2762
2763 case '\n':
2764 pp_string (buffer, "\\n");
2765 break;
2766
2767 case '\r':
2768 pp_string (buffer, "\\r");
2769 break;
2770
2771 case '\t':
2772 pp_string (buffer, "\\t");
2773 break;
2774
2775 case '\v':
2776 pp_string (buffer, "\\v");
2777 break;
2778
2779 case '\\':
2780 pp_string (buffer, "\\\\");
2781 break;
2782
2783 case '\"':
2784 pp_string (buffer, "\\\"");
2785 break;
2786
2787 case '\'':
2788 pp_string (buffer, "\\'");
2789 break;
2790
2791 /* No need to handle \0; the loop terminates on \0. */
2792
2793 case '\1':
2794 pp_string (buffer, "\\1");
2795 break;
2796
2797 case '\2':
2798 pp_string (buffer, "\\2");
2799 break;
2800
2801 case '\3':
2802 pp_string (buffer, "\\3");
2803 break;
2804
2805 case '\4':
2806 pp_string (buffer, "\\4");
2807 break;
2808
2809 case '\5':
2810 pp_string (buffer, "\\5");
2811 break;
2812
2813 case '\6':
2814 pp_string (buffer, "\\6");
2815 break;
2816
2817 case '\7':
2818 pp_string (buffer, "\\7");
2819 break;
2820
2821 default:
2822 pp_character (buffer, str[0]);
2823 break;
2824 }
2825 str++;
2826 }
2827 }
2828
2829 static void
2830 maybe_init_pretty_print (FILE *file)
2831 {
2832 if (!initialized)
2833 {
2834 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2835 pp_needs_newline (&buffer) = true;
2836 initialized = 1;
2837 }
2838
2839 buffer.buffer->stream = file;
2840 }
2841
2842 static void
2843 newline_and_indent (pretty_printer *buffer, int spc)
2844 {
2845 pp_newline (buffer);
2846 INDENT (spc);
2847 }
2848
2849
2850 static void
2851 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2852 {
2853 struct voptype_d *vdefs;
2854 struct voptype_d *vuses;
2855 int i, n;
2856
2857 if (!ssa_operands_active () || !stmt_references_memory_p (stmt))
2858 return;
2859
2860 /* Even if the statement doesn't have virtual operators yet, it may
2861 contain symbol information (this happens before aliases have been
2862 computed). */
2863 if ((flags & TDF_MEMSYMS)
2864 && VUSE_OPS (stmt) == NULL
2865 && VDEF_OPS (stmt) == NULL)
2866 {
2867 if (LOADED_SYMS (stmt))
2868 {
2869 pp_string (buffer, "# LOADS: ");
2870 dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2871 newline_and_indent (buffer, spc);
2872 }
2873
2874 if (STORED_SYMS (stmt))
2875 {
2876 pp_string (buffer, "# STORES: ");
2877 dump_symbols (buffer, STORED_SYMS (stmt), flags);
2878 newline_and_indent (buffer, spc);
2879 }
2880
2881 return;
2882 }
2883
2884 vuses = VUSE_OPS (stmt);
2885 while (vuses)
2886 {
2887 pp_string (buffer, "# VUSE <");
2888
2889 n = VUSE_NUM (vuses);
2890 for (i = 0; i < n; i++)
2891 {
2892 dump_generic_node (buffer, VUSE_OP (vuses, i), spc + 2, flags, false);
2893 if (i < n - 1)
2894 pp_string (buffer, ", ");
2895 }
2896
2897 pp_string (buffer, ">");
2898
2899 if (flags & TDF_MEMSYMS)
2900 dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2901
2902 newline_and_indent (buffer, spc);
2903 vuses = vuses->next;
2904 }
2905
2906 vdefs = VDEF_OPS (stmt);
2907 while (vdefs)
2908 {
2909 pp_string (buffer, "# ");
2910 dump_generic_node (buffer, VDEF_RESULT (vdefs), spc + 2, flags, false);
2911 pp_string (buffer, " = VDEF <");
2912
2913 n = VDEF_NUM (vdefs);
2914 for (i = 0; i < n; i++)
2915 {
2916 dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, 0);
2917 if (i < n - 1)
2918 pp_string (buffer, ", ");
2919 }
2920
2921 pp_string (buffer, ">");
2922
2923 if ((flags & TDF_MEMSYMS) && vdefs->next == NULL)
2924 dump_symbols (buffer, STORED_SYMS (stmt), flags);
2925
2926 newline_and_indent (buffer, spc);
2927 vdefs = vdefs->next;
2928 }
2929 }
2930
2931
2932 /* Dumps basic block BB to FILE with details described by FLAGS and
2933 indented by INDENT spaces. */
2934
2935 void
2936 dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2937 {
2938 maybe_init_pretty_print (file);
2939 dump_generic_bb_buff (&buffer, bb, indent, flags);
2940 pp_flush (&buffer);
2941 }
2942
2943 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2944 spaces and details described by flags. */
2945
2946 static void
2947 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2948 {
2949 edge e;
2950 tree stmt;
2951 edge_iterator ei;
2952
2953 if (flags & TDF_BLOCKS)
2954 {
2955 INDENT (indent);
2956 pp_string (buffer, "# BLOCK ");
2957 pp_decimal_int (buffer, bb->index);
2958 if (bb->frequency)
2959 {
2960 pp_string (buffer, " freq:");
2961 pp_decimal_int (buffer, bb->frequency);
2962 }
2963 if (bb->count)
2964 {
2965 pp_string (buffer, " count:");
2966 pp_widest_integer (buffer, bb->count);
2967 }
2968
2969 if (flags & TDF_LINENO)
2970 {
2971 block_stmt_iterator bsi;
2972
2973 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2974 if (get_lineno (bsi_stmt (bsi)) != -1)
2975 {
2976 pp_string (buffer, ", starting at line ");
2977 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2978 break;
2979 }
2980 }
2981 newline_and_indent (buffer, indent);
2982
2983 pp_string (buffer, "# PRED:");
2984 pp_write_text_to_stream (buffer);
2985 FOR_EACH_EDGE (e, ei, bb->preds)
2986 if (flags & TDF_SLIM)
2987 {
2988 pp_string (buffer, " ");
2989 if (e->src == ENTRY_BLOCK_PTR)
2990 pp_string (buffer, "ENTRY");
2991 else
2992 pp_decimal_int (buffer, e->src->index);
2993 }
2994 else
2995 dump_edge_info (buffer->buffer->stream, e, 0);
2996 pp_newline (buffer);
2997 }
2998 else
2999 {
3000 stmt = first_stmt (bb);
3001 if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
3002 {
3003 INDENT (indent - 2);
3004 pp_string (buffer, "<bb ");
3005 pp_decimal_int (buffer, bb->index);
3006 pp_string (buffer, ">:");
3007 pp_newline (buffer);
3008 }
3009 }
3010 pp_write_text_to_stream (buffer);
3011 check_bb_profile (bb, buffer->buffer->stream);
3012 }
3013
3014 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
3015 spaces. */
3016
3017 static void
3018 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
3019 {
3020 edge e;
3021 edge_iterator ei;
3022
3023 INDENT (indent);
3024 pp_string (buffer, "# SUCC:");
3025 pp_write_text_to_stream (buffer);
3026 FOR_EACH_EDGE (e, ei, bb->succs)
3027 if (flags & TDF_SLIM)
3028 {
3029 pp_string (buffer, " ");
3030 if (e->dest == EXIT_BLOCK_PTR)
3031 pp_string (buffer, "EXIT");
3032 else
3033 pp_decimal_int (buffer, e->dest->index);
3034 }
3035 else
3036 dump_edge_info (buffer->buffer->stream, e, 1);
3037 pp_newline (buffer);
3038 }
3039
3040 /* Dump PHI nodes of basic block BB to BUFFER with details described
3041 by FLAGS and indented by INDENT spaces. */
3042
3043 static void
3044 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
3045 {
3046 tree phi = phi_nodes (bb);
3047 if (!phi)
3048 return;
3049
3050 for (; phi; phi = PHI_CHAIN (phi))
3051 {
3052 if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
3053 {
3054 INDENT (indent);
3055 pp_string (buffer, "# ");
3056 dump_generic_node (buffer, phi, indent, flags, false);
3057 pp_newline (buffer);
3058 }
3059 }
3060 }
3061
3062
3063 /* Dump jump to basic block BB that is represented implicitly in the cfg
3064 to BUFFER. */
3065
3066 static void
3067 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
3068 {
3069 tree stmt;
3070
3071 stmt = first_stmt (bb);
3072
3073 pp_string (buffer, "goto <bb ");
3074 pp_decimal_int (buffer, bb->index);
3075 pp_string (buffer, ">");
3076 if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
3077 {
3078 pp_string (buffer, " (");
3079 dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
3080 pp_string (buffer, ")");
3081 }
3082 pp_semicolon (buffer);
3083 }
3084
3085 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
3086 by INDENT spaces, with details given by FLAGS. */
3087
3088 static void
3089 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
3090 int flags)
3091 {
3092 edge e;
3093 edge_iterator ei;
3094 tree stmt;
3095
3096 stmt = last_stmt (bb);
3097 if (stmt && TREE_CODE (stmt) == COND_EXPR)
3098 {
3099 edge true_edge, false_edge;
3100
3101 /* When we are emitting the code or changing CFG, it is possible that
3102 the edges are not yet created. When we are using debug_bb in such
3103 a situation, we do not want it to crash. */
3104 if (EDGE_COUNT (bb->succs) != 2)
3105 return;
3106 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
3107
3108 INDENT (indent + 2);
3109 pp_cfg_jump (buffer, true_edge->dest);
3110 newline_and_indent (buffer, indent);
3111 pp_string (buffer, "else");
3112 newline_and_indent (buffer, indent + 2);
3113 pp_cfg_jump (buffer, false_edge->dest);
3114 pp_newline (buffer);
3115 return;
3116 }
3117
3118 /* If there is a fallthru edge, we may need to add an artificial goto to the
3119 dump. */
3120 FOR_EACH_EDGE (e, ei, bb->succs)
3121 if (e->flags & EDGE_FALLTHRU)
3122 break;
3123 if (e && e->dest != bb->next_bb)
3124 {
3125 INDENT (indent);
3126
3127 if ((flags & TDF_LINENO) && e->goto_locus != UNKNOWN_LOCATION)
3128 {
3129 expanded_location goto_xloc;
3130 goto_xloc = expand_location (e->goto_locus);
3131 pp_character (buffer, '[');
3132 if (goto_xloc.file)
3133 {
3134 pp_string (buffer, goto_xloc.file);
3135 pp_string (buffer, " : ");
3136 }
3137 pp_decimal_int (buffer, goto_xloc.line);
3138 pp_string (buffer, "] ");
3139 }
3140
3141 pp_cfg_jump (buffer, e->dest);
3142 pp_newline (buffer);
3143 }
3144 }
3145
3146 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
3147 indented by INDENT spaces. */
3148
3149 static void
3150 dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
3151 int indent, int flags)
3152 {
3153 block_stmt_iterator bsi;
3154 tree stmt;
3155 int label_indent = indent - 2;
3156
3157 if (label_indent < 0)
3158 label_indent = 0;
3159
3160 dump_bb_header (buffer, bb, indent, flags);
3161
3162 dump_phi_nodes (buffer, bb, indent, flags);
3163
3164 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
3165 {
3166 int curr_indent;
3167
3168 stmt = bsi_stmt (bsi);
3169
3170 curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
3171
3172 INDENT (curr_indent);
3173 dump_generic_node (buffer, stmt, curr_indent, flags, true);
3174 pp_newline (buffer);
3175 dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
3176 }
3177
3178 dump_implicit_edges (buffer, bb, indent, flags);
3179
3180 if (flags & TDF_BLOCKS)
3181 dump_bb_end (buffer, bb, indent, flags);
3182 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org