Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-pretty-print.c @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children 77e2b8dfacca
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
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 SYMBOL_MEMORY_TAG:
885 case NAME_MEMORY_TAG:
886 case VAR_DECL:
887 case PARM_DECL:
888 case FIELD_DECL:
889 case NAMESPACE_DECL:
890 case MEMORY_PARTITION_TAG:
891 dump_decl_name (buffer, node, flags);
892 break;
893
894 case RESULT_DECL:
895 pp_string (buffer, "<retval>");
896 break;
897
898 case COMPONENT_REF:
899 op0 = TREE_OPERAND (node, 0);
900 str = ".";
901 if (TREE_CODE (op0) == INDIRECT_REF)
902 {
903 op0 = TREE_OPERAND (op0, 0);
904 str = "->";
905 }
906 if (op_prio (op0) < op_prio (node))
907 pp_character (buffer, '(');
908 dump_generic_node (buffer, op0, spc, flags, false);
909 if (op_prio (op0) < op_prio (node))
910 pp_character (buffer, ')');
911 pp_string (buffer, str);
912 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
913 op0 = component_ref_field_offset (node);
914 if (op0 && TREE_CODE (op0) != INTEGER_CST)
915 {
916 pp_string (buffer, "{off: ");
917 dump_generic_node (buffer, op0, spc, flags, false);
918 pp_character (buffer, '}');
919 }
920 break;
921
922 case BIT_FIELD_REF:
923 pp_string (buffer, "BIT_FIELD_REF <");
924 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
925 pp_string (buffer, ", ");
926 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
927 pp_string (buffer, ", ");
928 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
929 pp_string (buffer, ">");
930 break;
931
932 case ARRAY_REF:
933 case ARRAY_RANGE_REF:
934 op0 = TREE_OPERAND (node, 0);
935 if (op_prio (op0) < op_prio (node))
936 pp_character (buffer, '(');
937 dump_generic_node (buffer, op0, spc, flags, false);
938 if (op_prio (op0) < op_prio (node))
939 pp_character (buffer, ')');
940 pp_character (buffer, '[');
941 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
942 if (TREE_CODE (node) == ARRAY_RANGE_REF)
943 pp_string (buffer, " ...");
944 pp_character (buffer, ']');
945
946 op0 = array_ref_low_bound (node);
947 op1 = array_ref_element_size (node);
948
949 if (!integer_zerop (op0)
950 || TREE_OPERAND (node, 2)
951 || TREE_OPERAND (node, 3))
952 {
953 pp_string (buffer, "{lb: ");
954 dump_generic_node (buffer, op0, spc, flags, false);
955 pp_string (buffer, " sz: ");
956 dump_generic_node (buffer, op1, spc, flags, false);
957 pp_character (buffer, '}');
958 }
959 break;
960
961 case CONSTRUCTOR:
962 {
963 unsigned HOST_WIDE_INT ix;
964 tree field, val;
965 bool is_struct_init = FALSE;
966 pp_character (buffer, '{');
967 if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
968 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
969 is_struct_init = TRUE;
970 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
971 {
972 if (field && is_struct_init)
973 {
974 pp_character (buffer, '.');
975 dump_generic_node (buffer, field, spc, flags, false);
976 pp_string (buffer, "=");
977 }
978 if (val && TREE_CODE (val) == ADDR_EXPR)
979 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
980 val = TREE_OPERAND (val, 0);
981 if (val && TREE_CODE (val) == FUNCTION_DECL)
982 dump_decl_name (buffer, val, flags);
983 else
984 dump_generic_node (buffer, val, spc, flags, false);
985 if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
986 {
987 pp_character (buffer, ',');
988 pp_space (buffer);
989 }
990 }
991 pp_character (buffer, '}');
992 }
993 break;
994
995 case COMPOUND_EXPR:
996 {
997 tree *tp;
998 if (flags & TDF_SLIM)
999 {
1000 pp_string (buffer, "<COMPOUND_EXPR>");
1001 break;
1002 }
1003
1004 dump_generic_node (buffer, TREE_OPERAND (node, 0),
1005 spc, flags, !(flags & TDF_SLIM));
1006 if (flags & TDF_SLIM)
1007 newline_and_indent (buffer, spc);
1008 else
1009 {
1010 pp_character (buffer, ',');
1011 pp_space (buffer);
1012 }
1013
1014 for (tp = &TREE_OPERAND (node, 1);
1015 TREE_CODE (*tp) == COMPOUND_EXPR;
1016 tp = &TREE_OPERAND (*tp, 1))
1017 {
1018 dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
1019 spc, flags, !(flags & TDF_SLIM));
1020 if (flags & TDF_SLIM)
1021 newline_and_indent (buffer, spc);
1022 else
1023 {
1024 pp_character (buffer, ',');
1025 pp_space (buffer);
1026 }
1027 }
1028
1029 dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
1030 }
1031 break;
1032
1033 case STATEMENT_LIST:
1034 {
1035 tree_stmt_iterator si;
1036 bool first = true;
1037
1038 if (flags & TDF_SLIM)
1039 {
1040 pp_string (buffer, "<STATEMENT_LIST>");
1041 break;
1042 }
1043
1044 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1045 {
1046 if (!first)
1047 newline_and_indent (buffer, spc);
1048 else
1049 first = false;
1050 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
1051 }
1052 }
1053 break;
1054
1055 case MODIFY_EXPR:
1056 case INIT_EXPR:
1057 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags,
1058 false);
1059 pp_space (buffer);
1060 pp_character (buffer, '=');
1061 if (TREE_CODE (node) == MODIFY_EXPR
1062 && MOVE_NONTEMPORAL (node))
1063 pp_string (buffer, "{nt}");
1064 pp_space (buffer);
1065 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags,
1066 false);
1067 break;
1068
1069 case TARGET_EXPR:
1070 pp_string (buffer, "TARGET_EXPR <");
1071 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1072 pp_character (buffer, ',');
1073 pp_space (buffer);
1074 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
1075 pp_character (buffer, '>');
1076 break;
1077
1078 case DECL_EXPR:
1079 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1080 is_stmt = false;
1081 break;
1082
1083 case COND_EXPR:
1084 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1085 {
1086 pp_string (buffer, "if (");
1087 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1088 pp_character (buffer, ')');
1089 /* The lowered cond_exprs should always be printed in full. */
1090 if (COND_EXPR_THEN (node)
1091 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1092 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1093 && COND_EXPR_ELSE (node)
1094 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1095 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1096 {
1097 pp_space (buffer);
1098 dump_generic_node (buffer, COND_EXPR_THEN (node),
1099 0, flags, true);
1100 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1101 {
1102 pp_string (buffer, " else ");
1103 dump_generic_node (buffer, COND_EXPR_ELSE (node),
1104 0, flags, true);
1105 }
1106 }
1107 else if (!(flags & TDF_SLIM))
1108 {
1109 /* Output COND_EXPR_THEN. */
1110 if (COND_EXPR_THEN (node))
1111 {
1112 newline_and_indent (buffer, spc+2);
1113 pp_character (buffer, '{');
1114 newline_and_indent (buffer, spc+4);
1115 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1116 flags, true);
1117 newline_and_indent (buffer, spc+2);
1118 pp_character (buffer, '}');
1119 }
1120
1121 /* Output COND_EXPR_ELSE. */
1122 if (COND_EXPR_ELSE (node)
1123 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1124 {
1125 newline_and_indent (buffer, spc);
1126 pp_string (buffer, "else");
1127 newline_and_indent (buffer, spc+2);
1128 pp_character (buffer, '{');
1129 newline_and_indent (buffer, spc+4);
1130 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1131 flags, true);
1132 newline_and_indent (buffer, spc+2);
1133 pp_character (buffer, '}');
1134 }
1135 }
1136 is_expr = false;
1137 }
1138 else
1139 {
1140 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1141 pp_space (buffer);
1142 pp_character (buffer, '?');
1143 pp_space (buffer);
1144 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1145 pp_space (buffer);
1146 pp_character (buffer, ':');
1147 pp_space (buffer);
1148 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1149 }
1150 break;
1151
1152 case BIND_EXPR:
1153 pp_character (buffer, '{');
1154 if (!(flags & TDF_SLIM))
1155 {
1156 if (BIND_EXPR_VARS (node))
1157 {
1158 pp_newline (buffer);
1159
1160 for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
1161 {
1162 print_declaration (buffer, op0, spc+2, flags);
1163 pp_newline (buffer);
1164 }
1165 }
1166
1167 newline_and_indent (buffer, spc+2);
1168 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1169 newline_and_indent (buffer, spc);
1170 pp_character (buffer, '}');
1171 }
1172 is_expr = false;
1173 break;
1174
1175 case CALL_EXPR:
1176 print_call_name (buffer, node);
1177
1178 /* Print parameters. */
1179 pp_space (buffer);
1180 pp_character (buffer, '(');
1181 {
1182 tree arg;
1183 call_expr_arg_iterator iter;
1184 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
1185 {
1186 dump_generic_node (buffer, arg, spc, flags, false);
1187 if (more_call_expr_args_p (&iter))
1188 {
1189 pp_character (buffer, ',');
1190 pp_space (buffer);
1191 }
1192 }
1193 }
1194 if (CALL_EXPR_VA_ARG_PACK (node))
1195 {
1196 if (call_expr_nargs (node) > 0)
1197 {
1198 pp_character (buffer, ',');
1199 pp_space (buffer);
1200 }
1201 pp_string (buffer, "__builtin_va_arg_pack ()");
1202 }
1203 pp_character (buffer, ')');
1204
1205 op1 = CALL_EXPR_STATIC_CHAIN (node);
1206 if (op1)
1207 {
1208 pp_string (buffer, " [static-chain: ");
1209 dump_generic_node (buffer, op1, spc, flags, false);
1210 pp_character (buffer, ']');
1211 }
1212
1213 if (CALL_EXPR_RETURN_SLOT_OPT (node))
1214 pp_string (buffer, " [return slot optimization]");
1215 if (CALL_EXPR_TAILCALL (node))
1216 pp_string (buffer, " [tail call]");
1217 break;
1218
1219 case WITH_CLEANUP_EXPR:
1220 NIY;
1221 break;
1222
1223 case CLEANUP_POINT_EXPR:
1224 pp_string (buffer, "<<cleanup_point ");
1225 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1226 pp_string (buffer, ">>");
1227 break;
1228
1229 case PLACEHOLDER_EXPR:
1230 pp_string (buffer, "<PLACEHOLDER_EXPR ");
1231 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1232 pp_character (buffer, '>');
1233 break;
1234
1235 /* Binary arithmetic and logic expressions. */
1236 case WIDEN_SUM_EXPR:
1237 case WIDEN_MULT_EXPR:
1238 case MULT_EXPR:
1239 case PLUS_EXPR:
1240 case POINTER_PLUS_EXPR:
1241 case MINUS_EXPR:
1242 case TRUNC_DIV_EXPR:
1243 case CEIL_DIV_EXPR:
1244 case FLOOR_DIV_EXPR:
1245 case ROUND_DIV_EXPR:
1246 case TRUNC_MOD_EXPR:
1247 case CEIL_MOD_EXPR:
1248 case FLOOR_MOD_EXPR:
1249 case ROUND_MOD_EXPR:
1250 case RDIV_EXPR:
1251 case EXACT_DIV_EXPR:
1252 case LSHIFT_EXPR:
1253 case RSHIFT_EXPR:
1254 case LROTATE_EXPR:
1255 case RROTATE_EXPR:
1256 case VEC_LSHIFT_EXPR:
1257 case VEC_RSHIFT_EXPR:
1258 case BIT_IOR_EXPR:
1259 case BIT_XOR_EXPR:
1260 case BIT_AND_EXPR:
1261 case TRUTH_ANDIF_EXPR:
1262 case TRUTH_ORIF_EXPR:
1263 case TRUTH_AND_EXPR:
1264 case TRUTH_OR_EXPR:
1265 case TRUTH_XOR_EXPR:
1266 case LT_EXPR:
1267 case LE_EXPR:
1268 case GT_EXPR:
1269 case GE_EXPR:
1270 case EQ_EXPR:
1271 case NE_EXPR:
1272 case UNLT_EXPR:
1273 case UNLE_EXPR:
1274 case UNGT_EXPR:
1275 case UNGE_EXPR:
1276 case UNEQ_EXPR:
1277 case LTGT_EXPR:
1278 case ORDERED_EXPR:
1279 case UNORDERED_EXPR:
1280 {
1281 const char *op = op_symbol (node);
1282 op0 = TREE_OPERAND (node, 0);
1283 op1 = TREE_OPERAND (node, 1);
1284
1285 /* When the operands are expressions with less priority,
1286 keep semantics of the tree representation. */
1287 if (op_prio (op0) <= op_prio (node))
1288 {
1289 pp_character (buffer, '(');
1290 dump_generic_node (buffer, op0, spc, flags, false);
1291 pp_character (buffer, ')');
1292 }
1293 else
1294 dump_generic_node (buffer, op0, spc, flags, false);
1295
1296 pp_space (buffer);
1297 pp_string (buffer, op);
1298 pp_space (buffer);
1299
1300 /* When the operands are expressions with less priority,
1301 keep semantics of the tree representation. */
1302 if (op_prio (op1) <= op_prio (node))
1303 {
1304 pp_character (buffer, '(');
1305 dump_generic_node (buffer, op1, spc, flags, false);
1306 pp_character (buffer, ')');
1307 }
1308 else
1309 dump_generic_node (buffer, op1, spc, flags, false);
1310 }
1311 break;
1312
1313 /* Unary arithmetic and logic expressions. */
1314 case NEGATE_EXPR:
1315 case BIT_NOT_EXPR:
1316 case TRUTH_NOT_EXPR:
1317 case ADDR_EXPR:
1318 case PREDECREMENT_EXPR:
1319 case PREINCREMENT_EXPR:
1320 case ALIGN_INDIRECT_REF:
1321 case MISALIGNED_INDIRECT_REF:
1322 case INDIRECT_REF:
1323 if (TREE_CODE (node) == ADDR_EXPR
1324 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1325 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1326 ; /* Do not output '&' for strings and function pointers. */
1327 else
1328 pp_string (buffer, op_symbol (node));
1329
1330 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1331 {
1332 pp_character (buffer, '(');
1333 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1334 pp_character (buffer, ')');
1335 }
1336 else
1337 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1338
1339 if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1340 {
1341 pp_string (buffer, "{misalignment: ");
1342 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1343 pp_character (buffer, '}');
1344 }
1345 break;
1346
1347 case POSTDECREMENT_EXPR:
1348 case POSTINCREMENT_EXPR:
1349 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1350 {
1351 pp_character (buffer, '(');
1352 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1353 pp_character (buffer, ')');
1354 }
1355 else
1356 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1357 pp_string (buffer, op_symbol (node));
1358 break;
1359
1360 case MIN_EXPR:
1361 pp_string (buffer, "MIN_EXPR <");
1362 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1363 pp_string (buffer, ", ");
1364 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1365 pp_character (buffer, '>');
1366 break;
1367
1368 case MAX_EXPR:
1369 pp_string (buffer, "MAX_EXPR <");
1370 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1371 pp_string (buffer, ", ");
1372 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1373 pp_character (buffer, '>');
1374 break;
1375
1376 case ABS_EXPR:
1377 pp_string (buffer, "ABS_EXPR <");
1378 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1379 pp_character (buffer, '>');
1380 break;
1381
1382 case RANGE_EXPR:
1383 NIY;
1384 break;
1385
1386 case FIXED_CONVERT_EXPR:
1387 case FIX_TRUNC_EXPR:
1388 case FLOAT_EXPR:
1389 CASE_CONVERT:
1390 type = TREE_TYPE (node);
1391 op0 = TREE_OPERAND (node, 0);
1392 if (type != TREE_TYPE (op0))
1393 {
1394 pp_character (buffer, '(');
1395 dump_generic_node (buffer, type, spc, flags, false);
1396 pp_string (buffer, ") ");
1397 }
1398 if (op_prio (op0) < op_prio (node))
1399 pp_character (buffer, '(');
1400 dump_generic_node (buffer, op0, spc, flags, false);
1401 if (op_prio (op0) < op_prio (node))
1402 pp_character (buffer, ')');
1403 break;
1404
1405 case VIEW_CONVERT_EXPR:
1406 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1407 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1408 pp_string (buffer, ">(");
1409 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1410 pp_character (buffer, ')');
1411 break;
1412
1413 case PAREN_EXPR:
1414 pp_string (buffer, "((");
1415 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1416 pp_string (buffer, "))");
1417 break;
1418
1419 case NON_LVALUE_EXPR:
1420 pp_string (buffer, "NON_LVALUE_EXPR <");
1421 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1422 pp_character (buffer, '>');
1423 break;
1424
1425 case SAVE_EXPR:
1426 pp_string (buffer, "SAVE_EXPR <");
1427 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1428 pp_character (buffer, '>');
1429 break;
1430
1431 case COMPLEX_EXPR:
1432 pp_string (buffer, "COMPLEX_EXPR <");
1433 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1434 pp_string (buffer, ", ");
1435 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1436 pp_string (buffer, ">");
1437 break;
1438
1439 case CONJ_EXPR:
1440 pp_string (buffer, "CONJ_EXPR <");
1441 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1442 pp_string (buffer, ">");
1443 break;
1444
1445 case REALPART_EXPR:
1446 pp_string (buffer, "REALPART_EXPR <");
1447 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1448 pp_string (buffer, ">");
1449 break;
1450
1451 case IMAGPART_EXPR:
1452 pp_string (buffer, "IMAGPART_EXPR <");
1453 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1454 pp_string (buffer, ">");
1455 break;
1456
1457 case VA_ARG_EXPR:
1458 pp_string (buffer, "VA_ARG_EXPR <");
1459 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1460 pp_string (buffer, ">");
1461 break;
1462
1463 case TRY_FINALLY_EXPR:
1464 case TRY_CATCH_EXPR:
1465 pp_string (buffer, "try");
1466 newline_and_indent (buffer, spc+2);
1467 pp_string (buffer, "{");
1468 newline_and_indent (buffer, spc+4);
1469 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1470 newline_and_indent (buffer, spc+2);
1471 pp_string (buffer, "}");
1472 newline_and_indent (buffer, spc);
1473 pp_string (buffer,
1474 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1475 newline_and_indent (buffer, spc+2);
1476 pp_string (buffer, "{");
1477 newline_and_indent (buffer, spc+4);
1478 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1479 newline_and_indent (buffer, spc+2);
1480 pp_string (buffer, "}");
1481 is_expr = false;
1482 break;
1483
1484 case CATCH_EXPR:
1485 pp_string (buffer, "catch (");
1486 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1487 pp_string (buffer, ")");
1488 newline_and_indent (buffer, spc+2);
1489 pp_string (buffer, "{");
1490 newline_and_indent (buffer, spc+4);
1491 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1492 newline_and_indent (buffer, spc+2);
1493 pp_string (buffer, "}");
1494 is_expr = false;
1495 break;
1496
1497 case EH_FILTER_EXPR:
1498 pp_string (buffer, "<<<eh_filter (");
1499 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1500 pp_string (buffer, ")>>>");
1501 newline_and_indent (buffer, spc+2);
1502 pp_string (buffer, "{");
1503 newline_and_indent (buffer, spc+4);
1504 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1505 newline_and_indent (buffer, spc+2);
1506 pp_string (buffer, "}");
1507 is_expr = false;
1508 break;
1509
1510 case CHANGE_DYNAMIC_TYPE_EXPR:
1511 pp_string (buffer, "<<<change_dynamic_type (");
1512 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_NEW_TYPE (node), spc + 2,
1513 flags, false);
1514 pp_string (buffer, ") ");
1515 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_LOCATION (node), spc + 2,
1516 flags, false);
1517 pp_string (buffer, ")>>>");
1518 is_expr = false;
1519 break;
1520
1521 case LABEL_EXPR:
1522 op0 = TREE_OPERAND (node, 0);
1523 /* If this is for break or continue, don't bother printing it. */
1524 if (DECL_NAME (op0))
1525 {
1526 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1527 if (strcmp (name, "break") == 0
1528 || strcmp (name, "continue") == 0)
1529 break;
1530 }
1531 dump_generic_node (buffer, op0, spc, flags, false);
1532 pp_character (buffer, ':');
1533 if (DECL_NONLOCAL (op0))
1534 pp_string (buffer, " [non-local]");
1535 break;
1536
1537 case EXC_PTR_EXPR:
1538 pp_string (buffer, "<<<exception object>>>");
1539 break;
1540
1541 case FILTER_EXPR:
1542 pp_string (buffer, "<<<filter object>>>");
1543 break;
1544
1545 case LOOP_EXPR:
1546 pp_string (buffer, "while (1)");
1547 if (!(flags & TDF_SLIM))
1548 {
1549 newline_and_indent (buffer, spc+2);
1550 pp_character (buffer, '{');
1551 newline_and_indent (buffer, spc+4);
1552 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1553 newline_and_indent (buffer, spc+2);
1554 pp_character (buffer, '}');
1555 }
1556 is_expr = false;
1557 break;
1558
1559 case PREDICT_EXPR:
1560 pp_string (buffer, "// predicted ");
1561 if (PREDICT_EXPR_OUTCOME (node))
1562 pp_string (buffer, "likely by ");
1563 else
1564 pp_string (buffer, "unlikely by ");
1565 pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
1566 pp_string (buffer, " predictor.");
1567 break;
1568
1569 case RETURN_EXPR:
1570 pp_string (buffer, "return");
1571 op0 = TREE_OPERAND (node, 0);
1572 if (op0)
1573 {
1574 pp_space (buffer);
1575 if (TREE_CODE (op0) == MODIFY_EXPR)
1576 dump_generic_node (buffer, TREE_OPERAND (op0, 1),
1577 spc, flags, false);
1578 else
1579 dump_generic_node (buffer, op0, spc, flags, false);
1580 }
1581 break;
1582
1583 case EXIT_EXPR:
1584 pp_string (buffer, "if (");
1585 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1586 pp_string (buffer, ") break");
1587 break;
1588
1589 case SWITCH_EXPR:
1590 pp_string (buffer, "switch (");
1591 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1592 pp_character (buffer, ')');
1593 if (!(flags & TDF_SLIM))
1594 {
1595 newline_and_indent (buffer, spc+2);
1596 pp_character (buffer, '{');
1597 if (SWITCH_BODY (node))
1598 {
1599 newline_and_indent (buffer, spc+4);
1600 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1601 true);
1602 }
1603 else
1604 {
1605 tree vec = SWITCH_LABELS (node);
1606 size_t i, n = TREE_VEC_LENGTH (vec);
1607 for (i = 0; i < n; ++i)
1608 {
1609 tree elt = TREE_VEC_ELT (vec, i);
1610 newline_and_indent (buffer, spc+4);
1611 if (elt)
1612 {
1613 dump_generic_node (buffer, elt, spc+4, flags, false);
1614 pp_string (buffer, " goto ");
1615 dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1616 flags, true);
1617 pp_semicolon (buffer);
1618 }
1619 else
1620 pp_string (buffer, "case ???: goto ???;");
1621 }
1622 }
1623 newline_and_indent (buffer, spc+2);
1624 pp_character (buffer, '}');
1625 }
1626 is_expr = false;
1627 break;
1628
1629 case GOTO_EXPR:
1630 op0 = GOTO_DESTINATION (node);
1631 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1632 {
1633 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1634 if (strcmp (name, "break") == 0
1635 || strcmp (name, "continue") == 0)
1636 {
1637 pp_string (buffer, name);
1638 break;
1639 }
1640 }
1641 pp_string (buffer, "goto ");
1642 dump_generic_node (buffer, op0, spc, flags, false);
1643 break;
1644
1645 case RESX_EXPR:
1646 pp_string (buffer, "resx ");
1647 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1648 break;
1649
1650 case ASM_EXPR:
1651 pp_string (buffer, "__asm__");
1652 if (ASM_VOLATILE_P (node))
1653 pp_string (buffer, " __volatile__");
1654 pp_character (buffer, '(');
1655 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1656 pp_character (buffer, ':');
1657 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1658 pp_character (buffer, ':');
1659 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1660 if (ASM_CLOBBERS (node))
1661 {
1662 pp_character (buffer, ':');
1663 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1664 }
1665 pp_string (buffer, ")");
1666 break;
1667
1668 case CASE_LABEL_EXPR:
1669 if (CASE_LOW (node) && CASE_HIGH (node))
1670 {
1671 pp_string (buffer, "case ");
1672 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1673 pp_string (buffer, " ... ");
1674 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1675 }
1676 else if (CASE_LOW (node))
1677 {
1678 pp_string (buffer, "case ");
1679 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1680 }
1681 else
1682 pp_string (buffer, "default");
1683 pp_character (buffer, ':');
1684 break;
1685
1686 case OBJ_TYPE_REF:
1687 pp_string (buffer, "OBJ_TYPE_REF(");
1688 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1689 pp_character (buffer, ';');
1690 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1691 pp_character (buffer, '-');
1692 pp_character (buffer, '>');
1693 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1694 pp_character (buffer, ')');
1695 break;
1696
1697 case SSA_NAME:
1698 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1699 pp_string (buffer, "_");
1700 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1701 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1702 pp_string (buffer, "(ab)");
1703 else if (SSA_NAME_IS_DEFAULT_DEF (node))
1704 pp_string (buffer, "(D)");
1705 break;
1706
1707 case WITH_SIZE_EXPR:
1708 pp_string (buffer, "WITH_SIZE_EXPR <");
1709 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1710 pp_string (buffer, ", ");
1711 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1712 pp_string (buffer, ">");
1713 break;
1714
1715 case ASSERT_EXPR:
1716 pp_string (buffer, "ASSERT_EXPR <");
1717 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1718 pp_string (buffer, ", ");
1719 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1720 pp_string (buffer, ">");
1721 break;
1722
1723 case SCEV_KNOWN:
1724 pp_string (buffer, "scev_known");
1725 break;
1726
1727 case SCEV_NOT_KNOWN:
1728 pp_string (buffer, "scev_not_known");
1729 break;
1730
1731 case POLYNOMIAL_CHREC:
1732 pp_string (buffer, "{");
1733 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1734 pp_string (buffer, ", +, ");
1735 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1736 pp_string (buffer, "}_");
1737 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1738 is_stmt = false;
1739 break;
1740
1741 case REALIGN_LOAD_EXPR:
1742 pp_string (buffer, "REALIGN_LOAD <");
1743 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1744 pp_string (buffer, ", ");
1745 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1746 pp_string (buffer, ", ");
1747 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1748 pp_string (buffer, ">");
1749 break;
1750
1751 case VEC_COND_EXPR:
1752 pp_string (buffer, " VEC_COND_EXPR < ");
1753 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1754 pp_string (buffer, " , ");
1755 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1756 pp_string (buffer, " , ");
1757 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1758 pp_string (buffer, " > ");
1759 break;
1760
1761 case DOT_PROD_EXPR:
1762 pp_string (buffer, " DOT_PROD_EXPR < ");
1763 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1764 pp_string (buffer, ", ");
1765 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1766 pp_string (buffer, ", ");
1767 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1768 pp_string (buffer, " > ");
1769 break;
1770
1771 case OMP_PARALLEL:
1772 pp_string (buffer, "#pragma omp parallel");
1773 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
1774
1775 dump_omp_body:
1776 if (!(flags & TDF_SLIM) && OMP_BODY (node))
1777 {
1778 newline_and_indent (buffer, spc + 2);
1779 pp_character (buffer, '{');
1780 newline_and_indent (buffer, spc + 4);
1781 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
1782 newline_and_indent (buffer, spc + 2);
1783 pp_character (buffer, '}');
1784 }
1785 is_expr = false;
1786 break;
1787
1788 case OMP_TASK:
1789 pp_string (buffer, "#pragma omp task");
1790 dump_omp_clauses (buffer, OMP_TASK_CLAUSES (node), spc, flags);
1791 goto dump_omp_body;
1792
1793 case OMP_FOR:
1794 pp_string (buffer, "#pragma omp for");
1795 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
1796
1797 if (!(flags & TDF_SLIM))
1798 {
1799 int i;
1800
1801 if (OMP_FOR_PRE_BODY (node))
1802 {
1803 newline_and_indent (buffer, spc + 2);
1804 pp_character (buffer, '{');
1805 spc += 4;
1806 newline_and_indent (buffer, spc);
1807 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
1808 spc, flags, false);
1809 }
1810 spc -= 2;
1811 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
1812 {
1813 spc += 2;
1814 newline_and_indent (buffer, spc);
1815 pp_string (buffer, "for (");
1816 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INIT (node), i),
1817 spc, flags, false);
1818 pp_string (buffer, "; ");
1819 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_COND (node), i),
1820 spc, flags, false);
1821 pp_string (buffer, "; ");
1822 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i),
1823 spc, flags, false);
1824 pp_string (buffer, ")");
1825 }
1826 if (OMP_FOR_BODY (node))
1827 {
1828 newline_and_indent (buffer, spc + 2);
1829 pp_character (buffer, '{');
1830 newline_and_indent (buffer, spc + 4);
1831 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
1832 false);
1833 newline_and_indent (buffer, spc + 2);
1834 pp_character (buffer, '}');
1835 }
1836 spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
1837 if (OMP_FOR_PRE_BODY (node))
1838 {
1839 spc -= 4;
1840 newline_and_indent (buffer, spc + 2);
1841 pp_character (buffer, '}');
1842 }
1843 }
1844 is_expr = false;
1845 break;
1846
1847 case OMP_SECTIONS:
1848 pp_string (buffer, "#pragma omp sections");
1849 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
1850 goto dump_omp_body;
1851
1852 case OMP_SECTION:
1853 pp_string (buffer, "#pragma omp section");
1854 goto dump_omp_body;
1855
1856 case OMP_MASTER:
1857 pp_string (buffer, "#pragma omp master");
1858 goto dump_omp_body;
1859
1860 case OMP_ORDERED:
1861 pp_string (buffer, "#pragma omp ordered");
1862 goto dump_omp_body;
1863
1864 case OMP_CRITICAL:
1865 pp_string (buffer, "#pragma omp critical");
1866 if (OMP_CRITICAL_NAME (node))
1867 {
1868 pp_space (buffer);
1869 pp_character (buffer, '(');
1870 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
1871 flags, false);
1872 pp_character (buffer, ')');
1873 }
1874 goto dump_omp_body;
1875
1876 case OMP_ATOMIC:
1877 pp_string (buffer, "#pragma omp atomic");
1878 newline_and_indent (buffer, spc + 2);
1879 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1880 pp_space (buffer);
1881 pp_character (buffer, '=');
1882 pp_space (buffer);
1883 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1884 break;
1885
1886 case OMP_SINGLE:
1887 pp_string (buffer, "#pragma omp single");
1888 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
1889 goto dump_omp_body;
1890
1891 case OMP_CLAUSE:
1892 dump_omp_clause (buffer, node, spc, flags);
1893 is_expr = false;
1894 break;
1895
1896 case REDUC_MAX_EXPR:
1897 pp_string (buffer, " REDUC_MAX_EXPR < ");
1898 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1899 pp_string (buffer, " > ");
1900 break;
1901
1902 case REDUC_MIN_EXPR:
1903 pp_string (buffer, " REDUC_MIN_EXPR < ");
1904 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1905 pp_string (buffer, " > ");
1906 break;
1907
1908 case REDUC_PLUS_EXPR:
1909 pp_string (buffer, " REDUC_PLUS_EXPR < ");
1910 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1911 pp_string (buffer, " > ");
1912 break;
1913
1914 case VEC_WIDEN_MULT_HI_EXPR:
1915 pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
1916 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1917 pp_string (buffer, ", ");
1918 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1919 pp_string (buffer, " > ");
1920 break;
1921
1922 case VEC_WIDEN_MULT_LO_EXPR:
1923 pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
1924 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1925 pp_string (buffer, ", ");
1926 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1927 pp_string (buffer, " > ");
1928 break;
1929
1930 case VEC_UNPACK_HI_EXPR:
1931 pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
1932 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1933 pp_string (buffer, " > ");
1934 break;
1935
1936 case VEC_UNPACK_LO_EXPR:
1937 pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
1938 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1939 pp_string (buffer, " > ");
1940 break;
1941
1942 case VEC_UNPACK_FLOAT_HI_EXPR:
1943 pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");
1944 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1945 pp_string (buffer, " > ");
1946 break;
1947
1948 case VEC_UNPACK_FLOAT_LO_EXPR:
1949 pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");
1950 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1951 pp_string (buffer, " > ");
1952 break;
1953
1954 case VEC_PACK_TRUNC_EXPR:
1955 pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
1956 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1957 pp_string (buffer, ", ");
1958 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1959 pp_string (buffer, " > ");
1960 break;
1961
1962 case VEC_PACK_SAT_EXPR:
1963 pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
1964 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1965 pp_string (buffer, ", ");
1966 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1967 pp_string (buffer, " > ");
1968 break;
1969
1970 case VEC_PACK_FIX_TRUNC_EXPR:
1971 pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");
1972 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1973 pp_string (buffer, ", ");
1974 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1975 pp_string (buffer, " > ");
1976 break;
1977
1978 case BLOCK:
1979 {
1980 tree t;
1981 pp_string (buffer, "BLOCK");
1982
1983 if (BLOCK_ABSTRACT (node))
1984 pp_string (buffer, " [abstract]");
1985
1986 if (TREE_ASM_WRITTEN (node))
1987 pp_string (buffer, " [written]");
1988
1989 newline_and_indent (buffer, spc + 2);
1990
1991 if (BLOCK_SUPERCONTEXT (node))
1992 {
1993 pp_string (buffer, "SUPERCONTEXT: ");
1994 if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
1995 pp_printf (buffer, "BLOCK %p",
1996 (void *)BLOCK_SUPERCONTEXT (node));
1997 else
1998 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
1999 false);
2000 newline_and_indent (buffer, spc + 2);
2001 }
2002
2003 if (BLOCK_SUBBLOCKS (node))
2004 {
2005 pp_string (buffer, "SUBBLOCKS: ");
2006 for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
2007 pp_printf (buffer, "%p ", (void *)t);
2008 newline_and_indent (buffer, spc + 2);
2009 }
2010
2011 if (BLOCK_VARS (node))
2012 {
2013 pp_string (buffer, "VARS: ");
2014 for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
2015 {
2016 dump_generic_node (buffer, t, 0, flags, false);
2017 pp_string (buffer, " ");
2018 }
2019 newline_and_indent (buffer, spc + 2);
2020 }
2021
2022 if (BLOCK_ABSTRACT_ORIGIN (node))
2023 {
2024 pp_string (buffer, "ABSTRACT_ORIGIN: ");
2025 if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
2026 pp_printf (buffer, "BLOCK %p",
2027 (void *)BLOCK_ABSTRACT_ORIGIN (node));
2028 else
2029 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
2030 false);
2031 newline_and_indent (buffer, spc + 2);
2032 }
2033 }
2034 break;
2035
2036 case VEC_EXTRACT_EVEN_EXPR:
2037 pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
2038 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2039 pp_string (buffer, ", ");
2040 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2041 pp_string (buffer, " > ");
2042 break;
2043
2044 case VEC_EXTRACT_ODD_EXPR:
2045 pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
2046 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2047 pp_string (buffer, ", ");
2048 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2049 pp_string (buffer, " > ");
2050 break;
2051
2052 case VEC_INTERLEAVE_HIGH_EXPR:
2053 pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
2054 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2055 pp_string (buffer, ", ");
2056 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2057 pp_string (buffer, " > ");
2058 break;
2059
2060 case VEC_INTERLEAVE_LOW_EXPR:
2061 pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
2062 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2063 pp_string (buffer, ", ");
2064 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2065 pp_string (buffer, " > ");
2066 break;
2067
2068 default:
2069 NIY;
2070 }
2071
2072 if (is_stmt && is_expr)
2073 pp_semicolon (buffer);
2074
2075 /* If we're building a diagnostic, the formatted text will be written
2076 into BUFFER's stream by the caller; otherwise, write it now. */
2077 if (!(flags & TDF_DIAGNOSTIC))
2078 pp_write_text_to_stream (buffer);
2079
2080 return spc;
2081 }
2082
2083 /* Print the declaration of a variable. */
2084
2085 void
2086 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2087 {
2088 INDENT (spc);
2089
2090 if (TREE_CODE (t) == TYPE_DECL)
2091 pp_string (buffer, "typedef ");
2092
2093 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2094 pp_string (buffer, "register ");
2095
2096 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2097 pp_string (buffer, "extern ");
2098 else if (TREE_STATIC (t))
2099 pp_string (buffer, "static ");
2100
2101 /* Print the type and name. */
2102 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2103 {
2104 tree tmp;
2105
2106 /* Print array's type. */
2107 tmp = TREE_TYPE (t);
2108 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2109 tmp = TREE_TYPE (tmp);
2110 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2111
2112 /* Print variable's name. */
2113 pp_space (buffer);
2114 dump_generic_node (buffer, t, spc, flags, false);
2115
2116 /* Print the dimensions. */
2117 tmp = TREE_TYPE (t);
2118 while (TREE_CODE (tmp) == ARRAY_TYPE)
2119 {
2120 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
2121 tmp = TREE_TYPE (tmp);
2122 }
2123 }
2124 else if (TREE_CODE (t) == FUNCTION_DECL)
2125 {
2126 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2127 pp_space (buffer);
2128 dump_decl_name (buffer, t, flags);
2129 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2130 }
2131 else
2132 {
2133 /* Print type declaration. */
2134 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2135
2136 /* Print variable's name. */
2137 pp_space (buffer);
2138 dump_generic_node (buffer, t, spc, flags, false);
2139 }
2140
2141 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2142 {
2143 pp_string (buffer, " __asm__ ");
2144 pp_character (buffer, '(');
2145 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2146 pp_character (buffer, ')');
2147 }
2148
2149 /* The initial value of a function serves to determine whether the function
2150 is declared or defined. So the following does not apply to function
2151 nodes. */
2152 if (TREE_CODE (t) != FUNCTION_DECL)
2153 {
2154 /* Print the initial value. */
2155 if (DECL_INITIAL (t))
2156 {
2157 pp_space (buffer);
2158 pp_character (buffer, '=');
2159 pp_space (buffer);
2160 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2161 }
2162 }
2163
2164 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2165 {
2166 pp_string (buffer, " [value-expr: ");
2167 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2168 pp_character (buffer, ']');
2169 }
2170
2171 pp_character (buffer, ';');
2172 }
2173
2174
2175 /* Prints a structure: name, fields, and methods.
2176 FIXME: Still incomplete. */
2177
2178 static void
2179 print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
2180 {
2181 /* Print the name of the structure. */
2182 if (TYPE_NAME (node))
2183 {
2184 INDENT (spc);
2185 if (TREE_CODE (node) == RECORD_TYPE)
2186 pp_string (buffer, "struct ");
2187 else if ((TREE_CODE (node) == UNION_TYPE
2188 || TREE_CODE (node) == QUAL_UNION_TYPE))
2189 pp_string (buffer, "union ");
2190
2191 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2192 }
2193
2194 /* Print the contents of the structure. */
2195 pp_newline (buffer);
2196 INDENT (spc);
2197 pp_character (buffer, '{');
2198 pp_newline (buffer);
2199
2200 /* Print the fields of the structure. */
2201 {
2202 tree tmp;
2203 tmp = TYPE_FIELDS (node);
2204 while (tmp)
2205 {
2206 /* Avoid to print recursively the structure. */
2207 /* FIXME : Not implemented correctly...,
2208 what about the case when we have a cycle in the contain graph? ...
2209 Maybe this could be solved by looking at the scope in which the
2210 structure was declared. */
2211 if (TREE_TYPE (tmp) != node
2212 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
2213 && TREE_TYPE (TREE_TYPE (tmp)) != node))
2214 {
2215 print_declaration (buffer, tmp, spc+2, flags);
2216 pp_newline (buffer);
2217 }
2218 tmp = TREE_CHAIN (tmp);
2219 }
2220 }
2221 INDENT (spc);
2222 pp_character (buffer, '}');
2223 }
2224
2225 /* Return the priority of the operator CODE.
2226
2227 From lowest to highest precedence with either left-to-right (L-R)
2228 or right-to-left (R-L) associativity]:
2229
2230 1 [L-R] ,
2231 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2232 3 [R-L] ?:
2233 4 [L-R] ||
2234 5 [L-R] &&
2235 6 [L-R] |
2236 7 [L-R] ^
2237 8 [L-R] &
2238 9 [L-R] == !=
2239 10 [L-R] < <= > >=
2240 11 [L-R] << >>
2241 12 [L-R] + -
2242 13 [L-R] * / %
2243 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2244 15 [L-R] fn() [] -> .
2245
2246 unary +, - and * have higher precedence than the corresponding binary
2247 operators. */
2248
2249 int
2250 op_code_prio (enum tree_code code)
2251 {
2252 switch (code)
2253 {
2254 case TREE_LIST:
2255 case COMPOUND_EXPR:
2256 case BIND_EXPR:
2257 return 1;
2258
2259 case MODIFY_EXPR:
2260 case INIT_EXPR:
2261 return 2;
2262
2263 case COND_EXPR:
2264 return 3;
2265
2266 case TRUTH_OR_EXPR:
2267 case TRUTH_ORIF_EXPR:
2268 return 4;
2269
2270 case TRUTH_AND_EXPR:
2271 case TRUTH_ANDIF_EXPR:
2272 return 5;
2273
2274 case BIT_IOR_EXPR:
2275 return 6;
2276
2277 case BIT_XOR_EXPR:
2278 case TRUTH_XOR_EXPR:
2279 return 7;
2280
2281 case BIT_AND_EXPR:
2282 return 8;
2283
2284 case EQ_EXPR:
2285 case NE_EXPR:
2286 return 9;
2287
2288 case UNLT_EXPR:
2289 case UNLE_EXPR:
2290 case UNGT_EXPR:
2291 case UNGE_EXPR:
2292 case UNEQ_EXPR:
2293 case LTGT_EXPR:
2294 case ORDERED_EXPR:
2295 case UNORDERED_EXPR:
2296 case LT_EXPR:
2297 case LE_EXPR:
2298 case GT_EXPR:
2299 case GE_EXPR:
2300 return 10;
2301
2302 case LSHIFT_EXPR:
2303 case RSHIFT_EXPR:
2304 case LROTATE_EXPR:
2305 case RROTATE_EXPR:
2306 return 11;
2307
2308 case WIDEN_SUM_EXPR:
2309 case PLUS_EXPR:
2310 case POINTER_PLUS_EXPR:
2311 case MINUS_EXPR:
2312 return 12;
2313
2314 case VEC_WIDEN_MULT_HI_EXPR:
2315 case VEC_WIDEN_MULT_LO_EXPR:
2316 case WIDEN_MULT_EXPR:
2317 case DOT_PROD_EXPR:
2318 case MULT_EXPR:
2319 case TRUNC_DIV_EXPR:
2320 case CEIL_DIV_EXPR:
2321 case FLOOR_DIV_EXPR:
2322 case ROUND_DIV_EXPR:
2323 case RDIV_EXPR:
2324 case EXACT_DIV_EXPR:
2325 case TRUNC_MOD_EXPR:
2326 case CEIL_MOD_EXPR:
2327 case FLOOR_MOD_EXPR:
2328 case ROUND_MOD_EXPR:
2329 return 13;
2330
2331 case TRUTH_NOT_EXPR:
2332 case BIT_NOT_EXPR:
2333 case POSTINCREMENT_EXPR:
2334 case POSTDECREMENT_EXPR:
2335 case PREINCREMENT_EXPR:
2336 case PREDECREMENT_EXPR:
2337 case NEGATE_EXPR:
2338 case ALIGN_INDIRECT_REF:
2339 case MISALIGNED_INDIRECT_REF:
2340 case INDIRECT_REF:
2341 case ADDR_EXPR:
2342 case FLOAT_EXPR:
2343 CASE_CONVERT:
2344 case FIX_TRUNC_EXPR:
2345 case TARGET_EXPR:
2346 return 14;
2347
2348 case CALL_EXPR:
2349 case ARRAY_REF:
2350 case ARRAY_RANGE_REF:
2351 case COMPONENT_REF:
2352 return 15;
2353
2354 /* Special expressions. */
2355 case MIN_EXPR:
2356 case MAX_EXPR:
2357 case ABS_EXPR:
2358 case REALPART_EXPR:
2359 case IMAGPART_EXPR:
2360 case REDUC_MAX_EXPR:
2361 case REDUC_MIN_EXPR:
2362 case REDUC_PLUS_EXPR:
2363 case VEC_LSHIFT_EXPR:
2364 case VEC_RSHIFT_EXPR:
2365 case VEC_UNPACK_HI_EXPR:
2366 case VEC_UNPACK_LO_EXPR:
2367 case VEC_UNPACK_FLOAT_HI_EXPR:
2368 case VEC_UNPACK_FLOAT_LO_EXPR:
2369 case VEC_PACK_TRUNC_EXPR:
2370 case VEC_PACK_SAT_EXPR:
2371 return 16;
2372
2373 default:
2374 /* Return an arbitrarily high precedence to avoid surrounding single
2375 VAR_DECLs in ()s. */
2376 return 9999;
2377 }
2378 }
2379
2380 /* Return the priority of the operator OP. */
2381
2382 int
2383 op_prio (const_tree op)
2384 {
2385 enum tree_code code;
2386
2387 if (op == NULL)
2388 return 9999;
2389
2390 code = TREE_CODE (op);
2391 if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
2392 return op_prio (TREE_OPERAND (op, 0));
2393
2394 return op_code_prio (code);
2395 }
2396
2397 /* Return the symbol associated with operator CODE. */
2398
2399 const char *
2400 op_symbol_code (enum tree_code code)
2401 {
2402 switch (code)
2403 {
2404 case MODIFY_EXPR:
2405 return "=";
2406
2407 case TRUTH_OR_EXPR:
2408 case TRUTH_ORIF_EXPR:
2409 return "||";
2410
2411 case TRUTH_AND_EXPR:
2412 case TRUTH_ANDIF_EXPR:
2413 return "&&";
2414
2415 case BIT_IOR_EXPR:
2416 return "|";
2417
2418 case TRUTH_XOR_EXPR:
2419 case BIT_XOR_EXPR:
2420 return "^";
2421
2422 case ADDR_EXPR:
2423 case BIT_AND_EXPR:
2424 return "&";
2425
2426 case ORDERED_EXPR:
2427 return "ord";
2428 case UNORDERED_EXPR:
2429 return "unord";
2430
2431 case EQ_EXPR:
2432 return "==";
2433 case UNEQ_EXPR:
2434 return "u==";
2435
2436 case NE_EXPR:
2437 return "!=";
2438
2439 case LT_EXPR:
2440 return "<";
2441 case UNLT_EXPR:
2442 return "u<";
2443
2444 case LE_EXPR:
2445 return "<=";
2446 case UNLE_EXPR:
2447 return "u<=";
2448
2449 case GT_EXPR:
2450 return ">";
2451 case UNGT_EXPR:
2452 return "u>";
2453
2454 case GE_EXPR:
2455 return ">=";
2456 case UNGE_EXPR:
2457 return "u>=";
2458
2459 case LTGT_EXPR:
2460 return "<>";
2461
2462 case LSHIFT_EXPR:
2463 return "<<";
2464
2465 case RSHIFT_EXPR:
2466 return ">>";
2467
2468 case LROTATE_EXPR:
2469 return "r<<";
2470
2471 case RROTATE_EXPR:
2472 return "r>>";
2473
2474 case VEC_LSHIFT_EXPR:
2475 return "v<<";
2476
2477 case VEC_RSHIFT_EXPR:
2478 return "v>>";
2479
2480 case POINTER_PLUS_EXPR:
2481 return "+";
2482
2483 case PLUS_EXPR:
2484 return "+";
2485
2486 case REDUC_PLUS_EXPR:
2487 return "r+";
2488
2489 case WIDEN_SUM_EXPR:
2490 return "w+";
2491
2492 case WIDEN_MULT_EXPR:
2493 return "w*";
2494
2495 case NEGATE_EXPR:
2496 case MINUS_EXPR:
2497 return "-";
2498
2499 case BIT_NOT_EXPR:
2500 return "~";
2501
2502 case TRUTH_NOT_EXPR:
2503 return "!";
2504
2505 case MULT_EXPR:
2506 case INDIRECT_REF:
2507 return "*";
2508
2509 case ALIGN_INDIRECT_REF:
2510 return "A*";
2511
2512 case MISALIGNED_INDIRECT_REF:
2513 return "M*";
2514
2515 case TRUNC_DIV_EXPR:
2516 case RDIV_EXPR:
2517 return "/";
2518
2519 case CEIL_DIV_EXPR:
2520 return "/[cl]";
2521
2522 case FLOOR_DIV_EXPR:
2523 return "/[fl]";
2524
2525 case ROUND_DIV_EXPR:
2526 return "/[rd]";
2527
2528 case EXACT_DIV_EXPR:
2529 return "/[ex]";
2530
2531 case TRUNC_MOD_EXPR:
2532 return "%";
2533
2534 case CEIL_MOD_EXPR:
2535 return "%[cl]";
2536
2537 case FLOOR_MOD_EXPR:
2538 return "%[fl]";
2539
2540 case ROUND_MOD_EXPR:
2541 return "%[rd]";
2542
2543 case PREDECREMENT_EXPR:
2544 return " --";
2545
2546 case PREINCREMENT_EXPR:
2547 return " ++";
2548
2549 case POSTDECREMENT_EXPR:
2550 return "-- ";
2551
2552 case POSTINCREMENT_EXPR:
2553 return "++ ";
2554
2555 case MAX_EXPR:
2556 return "max";
2557
2558 case MIN_EXPR:
2559 return "min";
2560
2561 default:
2562 return "<<< ??? >>>";
2563 }
2564 }
2565
2566 /* Return the symbol associated with operator OP. */
2567
2568 static const char *
2569 op_symbol (const_tree op)
2570 {
2571 return op_symbol_code (TREE_CODE (op));
2572 }
2573
2574 /* Prints the name of a CALL_EXPR. */
2575
2576 static void
2577 print_call_name (pretty_printer *buffer, const_tree node)
2578 {
2579 tree op0;
2580
2581 gcc_assert (TREE_CODE (node) == CALL_EXPR);
2582
2583 op0 = CALL_EXPR_FN (node);
2584
2585 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2586 op0 = TREE_OPERAND (op0, 0);
2587
2588 switch (TREE_CODE (op0))
2589 {
2590 case VAR_DECL:
2591 case PARM_DECL:
2592 dump_function_name (buffer, op0);
2593 break;
2594
2595 case ADDR_EXPR:
2596 case INDIRECT_REF:
2597 case NOP_EXPR:
2598 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2599 break;
2600
2601 case COND_EXPR:
2602 pp_string (buffer, "(");
2603 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2604 pp_string (buffer, ") ? ");
2605 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
2606 pp_string (buffer, " : ");
2607 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
2608 break;
2609
2610 case COMPONENT_REF:
2611 /* The function is a pointer contained in a structure. */
2612 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
2613 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2614 dump_function_name (buffer, TREE_OPERAND (op0, 1));
2615 else
2616 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2617 /* else
2618 We can have several levels of structures and a function
2619 pointer inside. This is not implemented yet... */
2620 /* NIY;*/
2621 break;
2622
2623 case ARRAY_REF:
2624 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2625 dump_function_name (buffer, TREE_OPERAND (op0, 0));
2626 else
2627 dump_generic_node (buffer, op0, 0, 0, false);
2628 break;
2629
2630 case SSA_NAME:
2631 case OBJ_TYPE_REF:
2632 dump_generic_node (buffer, op0, 0, 0, false);
2633 break;
2634
2635 default:
2636 NIY;
2637 }
2638 }
2639
2640 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2641
2642 static void
2643 pretty_print_string (pretty_printer *buffer, const char *str)
2644 {
2645 if (str == NULL)
2646 return;
2647
2648 while (*str)
2649 {
2650 switch (str[0])
2651 {
2652 case '\b':
2653 pp_string (buffer, "\\b");
2654 break;
2655
2656 case '\f':
2657 pp_string (buffer, "\\f");
2658 break;
2659
2660 case '\n':
2661 pp_string (buffer, "\\n");
2662 break;
2663
2664 case '\r':
2665 pp_string (buffer, "\\r");
2666 break;
2667
2668 case '\t':
2669 pp_string (buffer, "\\t");
2670 break;
2671
2672 case '\v':
2673 pp_string (buffer, "\\v");
2674 break;
2675
2676 case '\\':
2677 pp_string (buffer, "\\\\");
2678 break;
2679
2680 case '\"':
2681 pp_string (buffer, "\\\"");
2682 break;
2683
2684 case '\'':
2685 pp_string (buffer, "\\'");
2686 break;
2687
2688 /* No need to handle \0; the loop terminates on \0. */
2689
2690 case '\1':
2691 pp_string (buffer, "\\1");
2692 break;
2693
2694 case '\2':
2695 pp_string (buffer, "\\2");
2696 break;
2697
2698 case '\3':
2699 pp_string (buffer, "\\3");
2700 break;
2701
2702 case '\4':
2703 pp_string (buffer, "\\4");
2704 break;
2705
2706 case '\5':
2707 pp_string (buffer, "\\5");
2708 break;
2709
2710 case '\6':
2711 pp_string (buffer, "\\6");
2712 break;
2713
2714 case '\7':
2715 pp_string (buffer, "\\7");
2716 break;
2717
2718 default:
2719 pp_character (buffer, str[0]);
2720 break;
2721 }
2722 str++;
2723 }
2724 }
2725
2726 static void
2727 maybe_init_pretty_print (FILE *file)
2728 {
2729 if (!initialized)
2730 {
2731 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2732 pp_needs_newline (&buffer) = true;
2733 initialized = 1;
2734 }
2735
2736 buffer.buffer->stream = file;
2737 }
2738
2739 static void
2740 newline_and_indent (pretty_printer *buffer, int spc)
2741 {
2742 pp_newline (buffer);
2743 INDENT (spc);
2744 }