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