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