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