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