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