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