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