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