]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/tree-pretty-print.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2005-04-05 Jakub Jelinek <jakub@redhat.com>
[thirdparty/gcc.git] / gcc / tree-pretty-print.c
CommitLineData
4ee9c684 1/* Pretty formatting of GENERIC trees in C syntax.
a6d108f6 2 Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4ee9c684 3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 2, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING. If not, write to the Free
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2002111-1307, USA. */
21
22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "tm.h"
26#include "errors.h"
27#include "tree.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"
101d9422 34#include "tree-chrec.h"
4ee9c684 35
36/* Local functions, macros and variables. */
37static int op_prio (tree);
38static const char *op_symbol (tree);
39static void pretty_print_string (pretty_printer *, const char*);
40static void print_call_name (pretty_printer *, tree);
41static void newline_and_indent (pretty_printer *, int);
42static void maybe_init_pretty_print (FILE *);
43static void print_declaration (pretty_printer *, tree, int, int);
44static void print_struct_decl (pretty_printer *, tree, int, int);
45static void do_niy (pretty_printer *, tree);
46static void dump_vops (pretty_printer *, tree, int, int);
47static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
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 ? \
5135beeb 56 lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
57 lang_hooks.decl_printable_name (NODE, 1))
4ee9c684 58
4ee9c684 59static pretty_printer buffer;
60static int initialized = 0;
61static bool dumping_stmts;
62
63/* Try to print something for an unknown tree code. */
64
65static void
66do_niy (pretty_printer *buffer, tree node)
67{
68 int i, len;
69
70 pp_string (buffer, "<<< Unknown tree: ");
71 pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
72
ce45a448 73 if (EXPR_P (node))
4ee9c684 74 {
651396d6 75 len = TREE_CODE_LENGTH (TREE_CODE (node));
4ee9c684 76 for (i = 0; i < len; ++i)
77 {
78 newline_and_indent (buffer, 2);
79 dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);
80 }
81 }
82
83 pp_string (buffer, " >>>\n");
84}
85
86void
87debug_generic_expr (tree t)
88{
89 print_generic_expr (stderr, t, TDF_VOPS|TDF_UID);
90 fprintf (stderr, "\n");
91}
92
93void
94debug_generic_stmt (tree t)
95{
96 print_generic_stmt (stderr, t, TDF_VOPS|TDF_UID);
97 fprintf (stderr, "\n");
98}
99
100/* Prints declaration DECL to the FILE with details specified by FLAGS. */
101void
102print_generic_decl (FILE *file, tree decl, int flags)
103{
104 maybe_init_pretty_print (file);
105 dumping_stmts = true;
106 print_declaration (&buffer, decl, 2, flags);
107 pp_write_text_to_stream (&buffer);
108}
109
110/* Print tree T, and its successors, on file FILE. FLAGS specifies details
111 to show in the dump. See TDF_* in tree.h. */
112
113void
114print_generic_stmt (FILE *file, tree t, int flags)
115{
116 maybe_init_pretty_print (file);
117 dumping_stmts = true;
118 dump_generic_node (&buffer, t, 0, flags, true);
119 pp_flush (&buffer);
120}
121
122/* Print tree T, and its successors, on file FILE. FLAGS specifies details
123 to show in the dump. See TDF_* in tree.h. The output is indented by
124 INDENT spaces. */
125
126void
127print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
128{
129 int i;
130
131 maybe_init_pretty_print (file);
132 dumping_stmts = true;
133
134 for (i = 0; i < indent; i++)
135 pp_space (&buffer);
136 dump_generic_node (&buffer, t, indent, flags, true);
137 pp_flush (&buffer);
138}
139
140/* Print a single expression T on file FILE. FLAGS specifies details to show
141 in the dump. See TDF_* in tree.h. */
142
143void
144print_generic_expr (FILE *file, tree t, int flags)
145{
146 maybe_init_pretty_print (file);
147 dumping_stmts = false;
148 dump_generic_node (&buffer, t, 0, flags, false);
149}
150
151/* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
152 in FLAGS. */
153
154static void
155dump_decl_name (pretty_printer *buffer, tree node, int flags)
156{
157 if (DECL_NAME (node))
158 pp_tree_identifier (buffer, DECL_NAME (node));
159
160 if ((flags & TDF_UID)
161 || DECL_NAME (node) == NULL_TREE)
162 {
163 if (TREE_CODE (node) == LABEL_DECL
164 && LABEL_DECL_UID (node) != -1)
4b118bc6 165 pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
4ee9c684 166 LABEL_DECL_UID (node));
167 else
e67e5e1f 168 {
169 char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
4b118bc6 170 pp_printf (buffer, "%c.%u", c, DECL_UID (node));
e67e5e1f 171 }
4ee9c684 172 }
173}
174
a1080ab2 175/* Like the above, but used for pretty printing function calls. */
176
177static void
178dump_function_name (pretty_printer *buffer, tree node)
179{
180 if (DECL_NAME (node))
181 PRINT_FUNCTION_NAME (node);
182 else
183 dump_decl_name (buffer, node, 0);
184}
185
d700b485 186/* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
187 FLAGS are as in dump_generic_node. */
188
189static void
190dump_function_declaration (pretty_printer *buffer, tree node,
191 int spc, int flags)
192{
193 bool wrote_arg = false;
194 tree arg;
195
196 pp_space (buffer);
197 pp_character (buffer, '(');
198
199 /* Print the argument types. The last element in the list is a VOID_TYPE.
200 The following avoids printing the last element. */
201 arg = TYPE_ARG_TYPES (node);
202 while (arg && TREE_CHAIN (arg) && arg != error_mark_node)
203 {
204 wrote_arg = true;
205 dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
206 arg = TREE_CHAIN (arg);
207 if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)
208 {
209 pp_character (buffer, ',');
210 pp_space (buffer);
211 }
212 }
213
214 if (!wrote_arg)
215 pp_string (buffer, "void");
216
217 pp_character (buffer, ')');
218}
219
9b1a6180 220/* Dump the domain associated with an array. */
221
222static void
223dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
224{
225 pp_character (buffer, '[');
226 if (domain)
227 {
228 tree min = TYPE_MIN_VALUE (domain);
229 tree max = TYPE_MAX_VALUE (domain);
230
231 if (min && max
232 && integer_zerop (min)
233 && host_integerp (max, 0))
234 pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
235 else
236 {
237 if (min)
238 dump_generic_node (buffer, min, spc, flags, false);
239 pp_character (buffer, ':');
240 if (max)
241 dump_generic_node (buffer, max, spc, flags, false);
242 }
243 }
244 else
245 pp_string (buffer, "<unknown>");
246 pp_character (buffer, ']');
247}
248
4ee9c684 249/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
250 FLAGS specifies details to show in the dump (see TDF_* in tree.h). If
251 IS_STMT is true, the object printed is considered to be a statement
252 and it is terminated by ';' if appropriate. */
253
254int
255dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
256 bool is_stmt)
257{
258 tree type;
259 tree op0, op1;
d700b485 260 const char *str;
4ee9c684 261 bool is_expr;
262
263 if (node == NULL_TREE)
264 return spc;
265
266 is_expr = EXPR_P (node);
267
268 if (TREE_CODE (node) != ERROR_MARK
269 && is_gimple_stmt (node)
270 && (flags & TDF_VOPS)
271 && stmt_ann (node))
272 dump_vops (buffer, node, spc, flags);
273
22aa74c4 274 if (is_stmt && (flags & TDF_STMTADDR))
275 pp_printf (buffer, "<&0x%x> ", (unsigned int)node);
276
4ee9c684 277 if (dumping_stmts
278 && (flags & TDF_LINENO)
279 && EXPR_HAS_LOCATION (node))
280 {
7bd3dcc4 281 expanded_location xloc = expand_location (EXPR_LOCATION (node));
4ee9c684 282 pp_character (buffer, '[');
7bd3dcc4 283 if (xloc.file)
4ee9c684 284 {
7bd3dcc4 285 pp_string (buffer, xloc.file);
4ee9c684 286 pp_string (buffer, " : ");
287 }
7bd3dcc4 288 pp_decimal_int (buffer, xloc.line);
4ee9c684 289 pp_string (buffer, "] ");
290 }
291
292 switch (TREE_CODE (node))
293 {
294 case ERROR_MARK:
295 pp_string (buffer, "<<< error >>>");
296 break;
297
298 case IDENTIFIER_NODE:
299 pp_tree_identifier (buffer, node);
300 break;
301
302 case TREE_LIST:
303 while (node && node != error_mark_node)
304 {
305 if (TREE_PURPOSE (node))
306 {
307 dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
308 pp_space (buffer);
309 }
310 dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
311 node = TREE_CHAIN (node);
312 if (node && TREE_CODE (node) == TREE_LIST)
313 {
314 pp_character (buffer, ',');
315 pp_space (buffer);
316 }
317 }
318 break;
319
dce3d064 320 case TREE_BINFO:
4ee9c684 321 dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
dce3d064 322
323 case TREE_VEC:
324 {
325 size_t i;
326 if (TREE_VEC_LENGTH (node) > 0)
327 {
328 size_t len = TREE_VEC_LENGTH (node);
329 for (i = 0; i < len - 1; i++)
330 {
331 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
332 false);
333 pp_character (buffer, ',');
334 pp_space (buffer);
335 }
336 dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
337 flags, false);
338 }
339 }
4ee9c684 340 break;
341
342 case BLOCK:
343 NIY;
344 break;
345
346 case VOID_TYPE:
347 case INTEGER_TYPE:
348 case REAL_TYPE:
349 case COMPLEX_TYPE:
350 case VECTOR_TYPE:
351 case ENUMERAL_TYPE:
352 case BOOLEAN_TYPE:
353 case CHAR_TYPE:
354 {
355 unsigned int quals = TYPE_QUALS (node);
ce45a448 356 enum tree_code_class class;
4ee9c684 357
358 if (quals & TYPE_QUAL_CONST)
359 pp_string (buffer, "const ");
360 else if (quals & TYPE_QUAL_VOLATILE)
361 pp_string (buffer, "volatile ");
362 else if (quals & TYPE_QUAL_RESTRICT)
363 pp_string (buffer, "restrict ");
364
365 class = TREE_CODE_CLASS (TREE_CODE (node));
366
ce45a448 367 if (class == tcc_declaration)
4ee9c684 368 {
369 if (DECL_NAME (node))
370 dump_decl_name (buffer, node, flags);
371 else
372 pp_string (buffer, "<unnamed type decl>");
373 }
ce45a448 374 else if (class == tcc_type)
4ee9c684 375 {
376 if (TYPE_NAME (node))
377 {
378 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
379 pp_tree_identifier (buffer, TYPE_NAME (node));
380 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
381 && DECL_NAME (TYPE_NAME (node)))
382 dump_decl_name (buffer, TYPE_NAME (node), flags);
383 else
5d8f2392 384 pp_string (buffer, "<unnamed type>");
385 }
386 else if (TREE_CODE (node) == VECTOR_TYPE)
387 {
388 pp_string (buffer, "vector ");
389 dump_generic_node (buffer, TREE_TYPE (node),
390 spc, flags, false);
4ee9c684 391 }
392 else
393 pp_string (buffer, "<unnamed type>");
394 }
395 break;
396 }
397
398 case POINTER_TYPE:
399 case REFERENCE_TYPE:
400 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
401
402 if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
403 {
404 tree fnode = TREE_TYPE (node);
d700b485 405
4ee9c684 406 dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
407 pp_space (buffer);
408 pp_character (buffer, '(');
409 pp_string (buffer, str);
410 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
411 dump_decl_name (buffer, TYPE_NAME (node), flags);
412 else
413 pp_printf (buffer, "<T%x>", TYPE_UID (node));
414
415 pp_character (buffer, ')');
d700b485 416 dump_function_declaration (buffer, fnode, spc, flags);
4ee9c684 417 }
418 else
419 {
420 unsigned int quals = TYPE_QUALS (node);
421
422 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
423 pp_space (buffer);
424 pp_string (buffer, str);
425
426 if (quals & TYPE_QUAL_CONST)
427 pp_string (buffer, " const");
428 else if (quals & TYPE_QUAL_VOLATILE)
429 pp_string (buffer, "volatile");
430 else if (quals & TYPE_QUAL_RESTRICT)
431 pp_string (buffer, " restrict");
90cea464 432
433 if (TYPE_REF_CAN_ALIAS_ALL (node))
434 pp_string (buffer, " {ref-all}");
4ee9c684 435 }
436 break;
437
438 case OFFSET_TYPE:
439 NIY;
440 break;
441
442 case METHOD_TYPE:
443 dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
444 pp_string (buffer, "::");
445 break;
446
4ee9c684 447 case ARRAY_TYPE:
448 {
449 tree tmp;
450
a0cac6f5 451 /* Print the innermost component type. */
452 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
453 tmp = TREE_TYPE (tmp))
454 ;
455 dump_generic_node (buffer, tmp, spc, flags, false);
4ee9c684 456
457 /* Print the dimensions. */
9b1a6180 458 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
459 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
4ee9c684 460 break;
461 }
462
4ee9c684 463 case RECORD_TYPE:
464 case UNION_TYPE:
6374121b 465 case QUAL_UNION_TYPE:
4ee9c684 466 /* Print the name of the structure. */
467 if (TREE_CODE (node) == RECORD_TYPE)
468 pp_string (buffer, "struct ");
469 else if (TREE_CODE (node) == UNION_TYPE)
470 pp_string (buffer, "union ");
471
472 if (TYPE_NAME (node))
473 dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
474 else
475 print_struct_decl (buffer, node, spc, flags);
476 break;
477
4ee9c684 478 case LANG_TYPE:
479 NIY;
480 break;
481
482 case INTEGER_CST:
483 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
484 {
485 /* In the case of a pointer, one may want to divide by the
486 size of the pointed-to type. Unfortunately, this not
487 straightforward. The C front-end maps expressions
488
489 (int *) 5
490 int *p; (p + 5)
491
492 in such a way that the two INTEGER_CST nodes for "5" have
493 different values but identical types. In the latter
494 case, the 5 is multiplied by sizeof (int) in c-common.c
495 (pointer_int_sum) to convert it to a byte address, and
496 yet the type of the node is left unchanged. Argh. What
497 is consistent though is that the number value corresponds
498 to bytes (UNITS) offset.
499
500 NB: Neither of the following divisors can be trivially
501 used to recover the original literal:
502
503 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
504 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
505 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
506 pp_string (buffer, "B"); /* pseudo-unit */
507 }
508 else if (! host_integerp (node, 0))
509 {
510 tree val = node;
511
512 if (tree_int_cst_sgn (val) < 0)
513 {
514 pp_character (buffer, '-');
7016c612 515 val = build_int_cst_wide (NULL_TREE,
516 -TREE_INT_CST_LOW (val),
517 ~TREE_INT_CST_HIGH (val)
518 + !TREE_INT_CST_LOW (val));
4ee9c684 519 }
520 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
521 systems? */
522 {
523 static char format[10]; /* "%x%09999x\0" */
524 if (!format[0])
525 sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
526 sprintf (pp_buffer (buffer)->digit_buffer, format,
527 TREE_INT_CST_HIGH (val),
528 TREE_INT_CST_LOW (val));
529 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
530 }
531 }
532 else
533 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
534 break;
535
536 case REAL_CST:
537 /* Code copied from print_node. */
538 {
539 REAL_VALUE_TYPE d;
540 if (TREE_OVERFLOW (node))
541 pp_string (buffer, " overflow");
542
543#if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
544 d = TREE_REAL_CST (node);
545 if (REAL_VALUE_ISINF (d))
546 pp_string (buffer, " Inf");
547 else if (REAL_VALUE_ISNAN (d))
548 pp_string (buffer, " Nan");
549 else
550 {
551 char string[100];
552 real_to_decimal (string, &d, sizeof (string), 0, 1);
553 pp_string (buffer, string);
554 }
555#else
556 {
557 HOST_WIDE_INT i;
558 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
559 pp_string (buffer, "0x");
560 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
561 output_formatted_integer (buffer, "%02x", *p++);
562 }
563#endif
564 break;
565 }
566
567 case COMPLEX_CST:
568 pp_string (buffer, "__complex__ (");
569 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
570 pp_string (buffer, ", ");
571 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
572 pp_string (buffer, ")");
573 break;
574
575 case STRING_CST:
576 pp_string (buffer, "\"");
577 pretty_print_string (buffer, TREE_STRING_POINTER (node));
578 pp_string (buffer, "\"");
579 break;
580
581 case VECTOR_CST:
582 {
583 tree elt;
584 pp_string (buffer, "{ ");
585 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
586 {
587 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
588 if (TREE_CHAIN (elt))
589 pp_string (buffer, ", ");
590 }
591 pp_string (buffer, " }");
592 }
593 break;
594
595 case FUNCTION_TYPE:
596 break;
597
598 case FUNCTION_DECL:
599 case CONST_DECL:
600 dump_decl_name (buffer, node, flags);
601 break;
602
603 case LABEL_DECL:
604 if (DECL_NAME (node))
605 dump_decl_name (buffer, node, flags);
606 else if (LABEL_DECL_UID (node) != -1)
607 pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
608 LABEL_DECL_UID (node));
609 else
610 pp_printf (buffer, "<D%u>", DECL_UID (node));
611 break;
612
613 case TYPE_DECL:
7bd3dcc4 614 if (DECL_IS_BUILTIN (node))
4ee9c684 615 {
616 /* Don't print the declaration of built-in types. */
617 break;
618 }
619 if (DECL_NAME (node))
d700b485 620 dump_decl_name (buffer, node, flags);
4ee9c684 621 else
622 {
efa75d92 623 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
624 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
625 && TYPE_METHODS (TREE_TYPE (node)))
4ee9c684 626 {
627 /* The type is a c++ class: all structures have at least
0bed3869 628 4 methods. */
4ee9c684 629 pp_string (buffer, "class ");
630 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
631 }
632 else
633 {
d700b485 634 pp_string (buffer,
635 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
636 ? "union" : "struct "));
4ee9c684 637 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
4ee9c684 638 }
639 }
640 break;
641
642 case VAR_DECL:
643 case PARM_DECL:
644 case FIELD_DECL:
645 case NAMESPACE_DECL:
646 dump_decl_name (buffer, node, flags);
647 break;
648
649 case RESULT_DECL:
650 pp_string (buffer, "<retval>");
651 break;
652
653 case COMPONENT_REF:
654 op0 = TREE_OPERAND (node, 0);
655 str = ".";
656 if (TREE_CODE (op0) == INDIRECT_REF)
657 {
658 op0 = TREE_OPERAND (op0, 0);
659 str = "->";
660 }
661 if (op_prio (op0) < op_prio (node))
662 pp_character (buffer, '(');
663 dump_generic_node (buffer, op0, spc, flags, false);
664 if (op_prio (op0) < op_prio (node))
665 pp_character (buffer, ')');
666 pp_string (buffer, str);
667 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1267d2b7 668
e3349ccb 669 if (TREE_CODE (op0) != VALUE_HANDLE)
6374121b 670 {
e3349ccb 671 op0 = component_ref_field_offset (node);
672 if (op0 && TREE_CODE (op0) != INTEGER_CST)
673 {
674 pp_string (buffer, "{off: ");
675 dump_generic_node (buffer, op0, spc, flags, false);
676 pp_character (buffer, '}');
677 }
6374121b 678 }
4ee9c684 679 break;
680
681 case BIT_FIELD_REF:
682 pp_string (buffer, "BIT_FIELD_REF <");
683 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
684 pp_string (buffer, ", ");
685 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
686 pp_string (buffer, ", ");
687 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
688 pp_string (buffer, ">");
689 break;
690
4ee9c684 691 case ARRAY_REF:
6374121b 692 case ARRAY_RANGE_REF:
4ee9c684 693 op0 = TREE_OPERAND (node, 0);
694 if (op_prio (op0) < op_prio (node))
695 pp_character (buffer, '(');
696 dump_generic_node (buffer, op0, spc, flags, false);
697 if (op_prio (op0) < op_prio (node))
698 pp_character (buffer, ')');
699 pp_character (buffer, '[');
700 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
6374121b 701 if (TREE_CODE (node) == ARRAY_RANGE_REF)
702 pp_string (buffer, " ...");
4ee9c684 703 pp_character (buffer, ']');
4ee9c684 704
1267d2b7 705 op0 = array_ref_low_bound (node);
706 op1 = array_ref_element_size (node);
707
708 if (!integer_zerop (op0)
709 || (TYPE_SIZE_UNIT (TREE_TYPE (node))
710 && !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0)))
6374121b 711 {
712 pp_string (buffer, "{lb: ");
1267d2b7 713 dump_generic_node (buffer, op0, spc, flags, false);
6374121b 714 pp_string (buffer, " sz: ");
1267d2b7 715 dump_generic_node (buffer, op1, spc, flags, false);
6374121b 716 pp_character (buffer, '}');
717 }
4ee9c684 718 break;
719
720 case CONSTRUCTOR:
721 {
722 tree lnode;
723 bool is_struct_init = FALSE;
724 pp_character (buffer, '{');
725 lnode = CONSTRUCTOR_ELTS (node);
726 if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
727 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
728 is_struct_init = TRUE;
729 while (lnode && lnode != error_mark_node)
730 {
731 tree val;
732 if (TREE_PURPOSE (lnode) && is_struct_init)
733 {
734 pp_character (buffer, '.');
735 dump_generic_node (buffer, TREE_PURPOSE (lnode), spc, flags, false);
736 pp_string (buffer, "=");
737 }
738 val = TREE_VALUE (lnode);
739 if (val && TREE_CODE (val) == ADDR_EXPR)
740 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
741 val = TREE_OPERAND (val, 0);
742 if (val && TREE_CODE (val) == FUNCTION_DECL)
743 {
744 dump_decl_name (buffer, val, flags);
745 }
746 else
747 {
748 dump_generic_node (buffer, TREE_VALUE (lnode), spc, flags, false);
749 }
750 lnode = TREE_CHAIN (lnode);
751 if (lnode && TREE_CODE (lnode) == TREE_LIST)
752 {
753 pp_character (buffer, ',');
754 pp_space (buffer);
755 }
756 }
757 pp_character (buffer, '}');
758 }
759 break;
760
761 case COMPOUND_EXPR:
762 {
763 tree *tp;
764 if (flags & TDF_SLIM)
765 {
766 pp_string (buffer, "<COMPOUND_EXPR>");
767 break;
768 }
769
770 dump_generic_node (buffer, TREE_OPERAND (node, 0),
771 spc, flags, dumping_stmts);
772 if (dumping_stmts)
773 newline_and_indent (buffer, spc);
774 else
775 {
776 pp_character (buffer, ',');
777 pp_space (buffer);
778 }
779
780 for (tp = &TREE_OPERAND (node, 1);
781 TREE_CODE (*tp) == COMPOUND_EXPR;
782 tp = &TREE_OPERAND (*tp, 1))
783 {
784 dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
785 spc, flags, dumping_stmts);
786 if (dumping_stmts)
787 newline_and_indent (buffer, spc);
788 else
789 {
790 pp_character (buffer, ',');
791 pp_space (buffer);
792 }
793 }
794
795 dump_generic_node (buffer, *tp, spc, flags, dumping_stmts);
796 }
797 break;
798
799 case STATEMENT_LIST:
800 {
801 tree_stmt_iterator si;
802 bool first = true;
b27ac6b5 803
4ee9c684 804 if ((flags & TDF_SLIM) || !dumping_stmts)
805 {
806 pp_string (buffer, "<STATEMENT_LIST>");
807 break;
808 }
809
810 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
811 {
812 if (!first)
813 newline_and_indent (buffer, spc);
814 else
815 first = false;
816 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
817 }
818 }
819 break;
820
821 case MODIFY_EXPR:
822 case INIT_EXPR:
823 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
824 pp_space (buffer);
825 pp_character (buffer, '=');
826 pp_space (buffer);
827 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
828 break;
829
830 case TARGET_EXPR:
2363ef00 831 pp_string (buffer, "TARGET_EXPR <");
832 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
833 pp_character (buffer, ',');
834 pp_space (buffer);
4ee9c684 835 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
2363ef00 836 pp_character (buffer, '>');
4ee9c684 837 break;
838
d700b485 839 case DECL_EXPR:
840 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
841 is_stmt = false;
842 break;
843
4ee9c684 844 case COND_EXPR:
0375a275 845 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
4ee9c684 846 {
847 pp_string (buffer, "if (");
848 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
849 pp_character (buffer, ')');
850 /* The lowered cond_exprs should always be printed in full. */
851 if (COND_EXPR_THEN (node)
49377e21 852 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
853 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
4ee9c684 854 && COND_EXPR_ELSE (node)
49377e21 855 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
856 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
4ee9c684 857 {
858 pp_space (buffer);
859 dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);
860 pp_string (buffer, " else ");
861 dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true);
862 }
863 else if (!(flags & TDF_SLIM))
864 {
865 /* Output COND_EXPR_THEN. */
866 if (COND_EXPR_THEN (node))
867 {
868 newline_and_indent (buffer, spc+2);
869 pp_character (buffer, '{');
870 newline_and_indent (buffer, spc+4);
871 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
872 flags, true);
873 newline_and_indent (buffer, spc+2);
874 pp_character (buffer, '}');
875 }
876
877 /* Output COND_EXPR_ELSE. */
878 if (COND_EXPR_ELSE (node))
879 {
880 newline_and_indent (buffer, spc);
881 pp_string (buffer, "else");
882 newline_and_indent (buffer, spc+2);
883 pp_character (buffer, '{');
884 newline_and_indent (buffer, spc+4);
885 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
886 flags, true);
887 newline_and_indent (buffer, spc+2);
888 pp_character (buffer, '}');
889 }
890 }
891 is_expr = false;
892 }
893 else
894 {
895 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
896 pp_space (buffer);
897 pp_character (buffer, '?');
898 pp_space (buffer);
899 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
900 pp_space (buffer);
901 pp_character (buffer, ':');
902 pp_space (buffer);
903 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
904 }
905 break;
906
907 case BIND_EXPR:
908 pp_character (buffer, '{');
909 if (!(flags & TDF_SLIM))
910 {
911 if (BIND_EXPR_VARS (node))
912 {
913 pp_newline (buffer);
914
915 for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
916 {
917 print_declaration (buffer, op0, spc+2, flags);
918 pp_newline (buffer);
919 }
920 }
921
922 newline_and_indent (buffer, spc+2);
923 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
924 newline_and_indent (buffer, spc);
925 pp_character (buffer, '}');
926 }
927 is_expr = false;
928 break;
929
930 case CALL_EXPR:
931 print_call_name (buffer, node);
932
933 /* Print parameters. */
934 pp_space (buffer);
935 pp_character (buffer, '(');
936 op1 = TREE_OPERAND (node, 1);
937 if (op1)
938 dump_generic_node (buffer, op1, spc, flags, false);
939 pp_character (buffer, ')');
940
941 op1 = TREE_OPERAND (node, 2);
942 if (op1)
943 {
944 pp_string (buffer, " [static-chain: ");
945 dump_generic_node (buffer, op1, spc, flags, false);
946 pp_character (buffer, ']');
947 }
948
6ad9daa3 949 if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (node))
950 pp_string (buffer, " [return slot addr]");
4ee9c684 951 if (CALL_EXPR_TAILCALL (node))
952 pp_string (buffer, " [tail call]");
953 break;
954
955 case WITH_CLEANUP_EXPR:
956 NIY;
957 break;
958
959 case CLEANUP_POINT_EXPR:
960 pp_string (buffer, "<<cleanup_point ");
961 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
962 pp_string (buffer, ">>");
963 break;
964
965 case PLACEHOLDER_EXPR:
d700b485 966 pp_string (buffer, "<PLACEHOLDER_EXPR ");
967 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
968 pp_character (buffer, '>');
4ee9c684 969 break;
970
971 /* Binary arithmetic and logic expressions. */
972 case MULT_EXPR:
973 case PLUS_EXPR:
974 case MINUS_EXPR:
975 case TRUNC_DIV_EXPR:
976 case CEIL_DIV_EXPR:
977 case FLOOR_DIV_EXPR:
978 case ROUND_DIV_EXPR:
979 case TRUNC_MOD_EXPR:
980 case CEIL_MOD_EXPR:
981 case FLOOR_MOD_EXPR:
982 case ROUND_MOD_EXPR:
983 case RDIV_EXPR:
984 case EXACT_DIV_EXPR:
985 case LSHIFT_EXPR:
986 case RSHIFT_EXPR:
987 case LROTATE_EXPR:
988 case RROTATE_EXPR:
989 case BIT_IOR_EXPR:
990 case BIT_XOR_EXPR:
991 case BIT_AND_EXPR:
992 case TRUTH_ANDIF_EXPR:
993 case TRUTH_ORIF_EXPR:
994 case TRUTH_AND_EXPR:
995 case TRUTH_OR_EXPR:
996 case TRUTH_XOR_EXPR:
997 case LT_EXPR:
998 case LE_EXPR:
999 case GT_EXPR:
1000 case GE_EXPR:
1001 case EQ_EXPR:
1002 case NE_EXPR:
1003 case UNLT_EXPR:
1004 case UNLE_EXPR:
1005 case UNGT_EXPR:
1006 case UNGE_EXPR:
1007 case UNEQ_EXPR:
318a728f 1008 case LTGT_EXPR:
1009 case ORDERED_EXPR:
1010 case UNORDERED_EXPR:
4ee9c684 1011 {
1012 const char *op = op_symbol (node);
1013 op0 = TREE_OPERAND (node, 0);
1014 op1 = TREE_OPERAND (node, 1);
1015
1016 /* When the operands are expressions with less priority,
1017 keep semantics of the tree representation. */
1018 if (op_prio (op0) < op_prio (node))
1019 {
1020 pp_character (buffer, '(');
1021 dump_generic_node (buffer, op0, spc, flags, false);
1022 pp_character (buffer, ')');
1023 }
1024 else
1025 dump_generic_node (buffer, op0, spc, flags, false);
1026
1027 pp_space (buffer);
1028 pp_string (buffer, op);
1029 pp_space (buffer);
1030
1031 /* When the operands are expressions with less priority,
1032 keep semantics of the tree representation. */
1033 if (op_prio (op1) < op_prio (node))
1034 {
1035 pp_character (buffer, '(');
1036 dump_generic_node (buffer, op1, spc, flags, false);
1037 pp_character (buffer, ')');
1038 }
1039 else
1040 dump_generic_node (buffer, op1, spc, flags, false);
1041 }
1042 break;
1043
1044 /* Unary arithmetic and logic expressions. */
1045 case NEGATE_EXPR:
1046 case BIT_NOT_EXPR:
1047 case TRUTH_NOT_EXPR:
1048 case ADDR_EXPR:
4ee9c684 1049 case PREDECREMENT_EXPR:
1050 case PREINCREMENT_EXPR:
b056d812 1051 case ALIGN_INDIRECT_REF:
1052 case MISALIGNED_INDIRECT_REF:
4ee9c684 1053 case INDIRECT_REF:
1054 if (TREE_CODE (node) == ADDR_EXPR
1055 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1056 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1057 ; /* Do not output '&' for strings and function pointers. */
1058 else
1059 pp_string (buffer, op_symbol (node));
1060
1061 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1062 {
1063 pp_character (buffer, '(');
1064 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1065 pp_character (buffer, ')');
1066 }
1067 else
1068 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
b056d812 1069
1070 if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1071 {
1072 pp_string (buffer, "{misalignment: ");
1073 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1074 pp_character (buffer, '}');
1075 }
4ee9c684 1076 break;
1077
1078 case POSTDECREMENT_EXPR:
1079 case POSTINCREMENT_EXPR:
1080 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1081 {
1082 pp_character (buffer, '(');
1083 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1084 pp_character (buffer, ')');
1085 }
1086 else
1087 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1088 pp_string (buffer, op_symbol (node));
1089 break;
1090
1091 case MIN_EXPR:
1092 pp_string (buffer, "MIN_EXPR <");
1093 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1094 pp_string (buffer, ", ");
1095 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1096 pp_character (buffer, '>');
1097 break;
1098
1099 case MAX_EXPR:
1100 pp_string (buffer, "MAX_EXPR <");
1101 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1102 pp_string (buffer, ", ");
1103 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1104 pp_character (buffer, '>');
1105 break;
1106
1107 case ABS_EXPR:
1108 pp_string (buffer, "ABS_EXPR <");
1109 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1110 pp_character (buffer, '>');
1111 break;
1112
4ee9c684 1113 case RANGE_EXPR:
1114 NIY;
1115 break;
1116
1117 case FIX_TRUNC_EXPR:
1118 case FIX_CEIL_EXPR:
1119 case FIX_FLOOR_EXPR:
1120 case FIX_ROUND_EXPR:
1121 case FLOAT_EXPR:
1122 case CONVERT_EXPR:
1123 case NOP_EXPR:
1124 type = TREE_TYPE (node);
1125 op0 = TREE_OPERAND (node, 0);
1126 if (type != TREE_TYPE (op0))
1127 {
1128 pp_character (buffer, '(');
1129 dump_generic_node (buffer, type, spc, flags, false);
153536df 1130 pp_string (buffer, ") ");
4ee9c684 1131 }
1132 if (op_prio (op0) < op_prio (node))
1133 pp_character (buffer, '(');
1134 dump_generic_node (buffer, op0, spc, flags, false);
1135 if (op_prio (op0) < op_prio (node))
1136 pp_character (buffer, ')');
1137 break;
1138
1139 case VIEW_CONVERT_EXPR:
1140 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1141 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1142 pp_string (buffer, ">(");
1143 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1144 pp_character (buffer, ')');
1145 break;
1146
1147 case NON_LVALUE_EXPR:
1148 pp_string (buffer, "NON_LVALUE_EXPR <");
1149 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1150 pp_character (buffer, '>');
1151 break;
1152
1153 case SAVE_EXPR:
1154 pp_string (buffer, "SAVE_EXPR <");
1155 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1156 pp_character (buffer, '>');
1157 break;
1158
4ee9c684 1159 case COMPLEX_EXPR:
1160 pp_string (buffer, "COMPLEX_EXPR <");
1161 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1162 pp_string (buffer, ", ");
1163 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1164 pp_string (buffer, ">");
1165 break;
1166
1167 case CONJ_EXPR:
1168 pp_string (buffer, "CONJ_EXPR <");
1169 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1170 pp_string (buffer, ">");
1171 break;
1172
1173 case REALPART_EXPR:
1174 pp_string (buffer, "REALPART_EXPR <");
1175 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1176 pp_string (buffer, ">");
1177 break;
1178
1179 case IMAGPART_EXPR:
1180 pp_string (buffer, "IMAGPART_EXPR <");
1181 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1182 pp_string (buffer, ">");
1183 break;
1184
1185 case VA_ARG_EXPR:
1186 pp_string (buffer, "VA_ARG_EXPR <");
1187 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1188 pp_string (buffer, ">");
1189 break;
1190
1191 case TRY_FINALLY_EXPR:
1192 case TRY_CATCH_EXPR:
1193 pp_string (buffer, "try");
1194 newline_and_indent (buffer, spc+2);
1195 pp_string (buffer, "{");
1196 newline_and_indent (buffer, spc+4);
1197 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1198 newline_and_indent (buffer, spc+2);
1199 pp_string (buffer, "}");
1200 newline_and_indent (buffer, spc);
1201 pp_string (buffer,
1202 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1203 newline_and_indent (buffer, spc+2);
1204 pp_string (buffer, "{");
1205 newline_and_indent (buffer, spc+4);
1206 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1207 newline_and_indent (buffer, spc+2);
1208 pp_string (buffer, "}");
1209 is_expr = false;
1210 break;
1211
1212 case CATCH_EXPR:
1213 pp_string (buffer, "catch (");
1214 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1215 pp_string (buffer, ")");
1216 newline_and_indent (buffer, spc+2);
1217 pp_string (buffer, "{");
1218 newline_and_indent (buffer, spc+4);
1219 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1220 newline_and_indent (buffer, spc+2);
1221 pp_string (buffer, "}");
1222 is_expr = false;
1223 break;
1224
1225 case EH_FILTER_EXPR:
1226 pp_string (buffer, "<<<eh_filter (");
1227 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1228 pp_string (buffer, ")>>>");
1229 newline_and_indent (buffer, spc+2);
1230 pp_string (buffer, "{");
1231 newline_and_indent (buffer, spc+4);
1232 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1233 newline_and_indent (buffer, spc+2);
1234 pp_string (buffer, "}");
1235 is_expr = false;
1236 break;
1237
4ee9c684 1238 case LABEL_EXPR:
1239 op0 = TREE_OPERAND (node, 0);
1240 /* If this is for break or continue, don't bother printing it. */
1241 if (DECL_NAME (op0))
1242 {
1243 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1244 if (strcmp (name, "break") == 0
1245 || strcmp (name, "continue") == 0)
1246 break;
1247 }
1248 dump_generic_node (buffer, op0, spc, flags, false);
1249 pp_character (buffer, ':');
1250 if (DECL_NONLOCAL (op0))
1251 pp_string (buffer, " [non-local]");
1252 break;
1253
4ee9c684 1254 case EXC_PTR_EXPR:
1255 pp_string (buffer, "<<<exception object>>>");
1256 break;
1257
1258 case FILTER_EXPR:
1259 pp_string (buffer, "<<<filter object>>>");
1260 break;
1261
1262 case LOOP_EXPR:
1263 pp_string (buffer, "while (1)");
1264 if (!(flags & TDF_SLIM))
1265 {
1266 newline_and_indent (buffer, spc+2);
1267 pp_character (buffer, '{');
1268 newline_and_indent (buffer, spc+4);
1269 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1270 newline_and_indent (buffer, spc+2);
1271 pp_character (buffer, '}');
1272 }
1273 is_expr = false;
1274 break;
1275
1276 case RETURN_EXPR:
1277 pp_string (buffer, "return");
1278 op0 = TREE_OPERAND (node, 0);
1279 if (op0)
1280 {
1281 pp_space (buffer);
1282 if (TREE_CODE (op0) == MODIFY_EXPR)
1283 dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);
1284 else
1285 dump_generic_node (buffer, op0, spc, flags, false);
1286 }
1287 break;
1288
1289 case EXIT_EXPR:
1290 pp_string (buffer, "if (");
1291 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1292 pp_string (buffer, ") break");
1293 break;
1294
1295 case SWITCH_EXPR:
1296 pp_string (buffer, "switch (");
1297 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1298 pp_character (buffer, ')');
1299 if (!(flags & TDF_SLIM))
1300 {
1301 newline_and_indent (buffer, spc+2);
1302 pp_character (buffer, '{');
1303 if (SWITCH_BODY (node))
1304 {
1305 newline_and_indent (buffer, spc+4);
1306 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags, true);
1307 }
1308 else
1309 {
1310 tree vec = SWITCH_LABELS (node);
1311 size_t i, n = TREE_VEC_LENGTH (vec);
1312 for (i = 0; i < n; ++i)
1313 {
1314 tree elt = TREE_VEC_ELT (vec, i);
1315 newline_and_indent (buffer, spc+4);
1316 dump_generic_node (buffer, elt, spc+4, flags, false);
1317 pp_string (buffer, " goto ");
1318 dump_generic_node (buffer, CASE_LABEL (elt), spc+4, flags, true);
1319 pp_semicolon (buffer);
1320 }
1321 }
1322 newline_and_indent (buffer, spc+2);
1323 pp_character (buffer, '}');
1324 }
1325 is_expr = false;
1326 break;
1327
1328 case GOTO_EXPR:
1329 op0 = GOTO_DESTINATION (node);
ce45a448 1330 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
4ee9c684 1331 {
1332 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1333 if (strcmp (name, "break") == 0
1334 || strcmp (name, "continue") == 0)
1335 {
1336 pp_string (buffer, name);
1337 break;
1338 }
1339 }
1340 pp_string (buffer, "goto ");
1341 dump_generic_node (buffer, op0, spc, flags, false);
1342 break;
1343
1344 case RESX_EXPR:
1345 pp_string (buffer, "resx");
1346 /* ??? Any sensible way to present the eh region? */
1347 break;
1348
1349 case ASM_EXPR:
1350 pp_string (buffer, "__asm__");
1351 if (ASM_VOLATILE_P (node))
1352 pp_string (buffer, " __volatile__");
1353 pp_character (buffer, '(');
1354 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1355 pp_character (buffer, ':');
1356 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1357 pp_character (buffer, ':');
1358 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1359 if (ASM_CLOBBERS (node))
1360 {
1361 pp_character (buffer, ':');
1362 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1363 }
1364 pp_string (buffer, ")");
1365 break;
1366
1367 case CASE_LABEL_EXPR:
1368 if (CASE_LOW (node) && CASE_HIGH (node))
1369 {
1370 pp_string (buffer, "case ");
1371 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1372 pp_string (buffer, " ... ");
1373 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1374 }
1375 else if (CASE_LOW (node))
1376 {
1377 pp_string (buffer, "case ");
1378 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1379 }
1380 else
1381 pp_string (buffer, "default ");
1382 pp_character (buffer, ':');
1383 break;
1384
215e2f1d 1385 case OBJ_TYPE_REF:
1386 pp_string (buffer, "OBJ_TYPE_REF(");
1387 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1388 pp_character (buffer, ';');
1389 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1390 pp_character (buffer, '-');
4ee9c684 1391 pp_character (buffer, '>');
215e2f1d 1392 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1393 pp_character (buffer, ')');
4ee9c684 1394 break;
1395
4ee9c684 1396 case PHI_NODE:
1397 {
1398 int i;
1399
1400 dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1401 pp_string (buffer, " = PHI <");
1402 for (i = 0; i < PHI_NUM_ARGS (node); i++)
1403 {
1404 dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1405 pp_string (buffer, "(");
1406 pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1407 pp_string (buffer, ")");
1408 if (i < PHI_NUM_ARGS (node) - 1)
1409 pp_string (buffer, ", ");
1410 }
1411 pp_string (buffer, ">;");
1412 }
1413 break;
1414
1415 case SSA_NAME:
1416 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1417 pp_string (buffer, "_");
1418 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1419 break;
1420
80f06481 1421 case WITH_SIZE_EXPR:
1422 pp_string (buffer, "WITH_SIZE_EXPR <");
1423 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1424 pp_string (buffer, ", ");
1425 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1426 pp_string (buffer, ">");
1427 break;
1428
6354ec2d 1429 case VALUE_HANDLE:
1430 pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1431 break;
1432
101d9422 1433 case SCEV_KNOWN:
1434 pp_string (buffer, "scev_known");
1435 break;
1436
1437 case SCEV_NOT_KNOWN:
1438 pp_string (buffer, "scev_not_known");
1439 break;
1440
1441 case POLYNOMIAL_CHREC:
1442 pp_string (buffer, "{");
1443 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1444 pp_string (buffer, ", +, ");
1445 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1446 pp_string (buffer, "}_");
1447 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1448 is_stmt = false;
1449 break;
1450
b056d812 1451 case REALIGN_LOAD_EXPR:
1452 pp_string (buffer, "REALIGN_LOAD <");
1453 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1454 pp_string (buffer, ", ");
1455 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1456 pp_string (buffer, ", ");
1457 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1458 pp_string (buffer, ">");
1459 break;
1460
5c4f2f32 1461 case VEC_COND_EXPR:
1462 pp_string (buffer, " VEC_COND_EXPR < ");
1463 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1464 pp_string (buffer, " , ");
1465 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1466 pp_string (buffer, " , ");
1467 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1468 pp_string (buffer, " > ");
1469 break;
1470
4ee9c684 1471 default:
1472 NIY;
1473 }
1474
1475 if (is_stmt && is_expr)
1476 pp_semicolon (buffer);
1477 pp_write_text_to_stream (buffer);
1478
1479 return spc;
1480}
1481
1482/* Print the declaration of a variable. */
1483
1484static void
1485print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
1486{
4ee9c684 1487 INDENT (spc);
1488
d700b485 1489 if (TREE_CODE (t) == TYPE_DECL)
1490 pp_string (buffer, "typedef ");
1491
4ee9c684 1492 if (DECL_REGISTER (t))
1493 pp_string (buffer, "register ");
1494
1495 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
1496 pp_string (buffer, "extern ");
1497 else if (TREE_STATIC (t))
1498 pp_string (buffer, "static ");
1499
1500 /* Print the type and name. */
1501 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
1502 {
1503 tree tmp;
1504
1505 /* Print array's type. */
1506 tmp = TREE_TYPE (t);
1507 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
1508 tmp = TREE_TYPE (tmp);
1509 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
1510
1511 /* Print variable's name. */
1512 pp_space (buffer);
1513 dump_generic_node (buffer, t, spc, flags, false);
1514
1515 /* Print the dimensions. */
1516 tmp = TREE_TYPE (t);
1517 while (TREE_CODE (tmp) == ARRAY_TYPE)
1518 {
9b1a6180 1519 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
4ee9c684 1520 tmp = TREE_TYPE (tmp);
1521 }
1522 }
d700b485 1523 else if (TREE_CODE (t) == FUNCTION_DECL)
1524 {
1525 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
1526 pp_space (buffer);
1527 dump_decl_name (buffer, t, flags);
1528 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
1529 }
4ee9c684 1530 else
1531 {
1532 /* Print type declaration. */
1533 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
1534
1535 /* Print variable's name. */
1536 pp_space (buffer);
1537 dump_generic_node (buffer, t, spc, flags, false);
1538 }
1539
fbc51f36 1540 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
1541 {
1542 pp_string (buffer, " __asm__ ");
1543 pp_character (buffer, '(');
1544 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
1545 pp_character (buffer, ')');
1546 }
1547
4ee9c684 1548 /* The initial value of a function serves to determine wether the function
1549 is declared or defined. So the following does not apply to function
1550 nodes. */
1551 if (TREE_CODE (t) != FUNCTION_DECL)
1552 {
1553 /* Print the initial value. */
1554 if (DECL_INITIAL (t))
1555 {
1556 pp_space (buffer);
1557 pp_character (buffer, '=');
1558 pp_space (buffer);
1559 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
1560 }
1561 }
1562
1563 pp_character (buffer, ';');
1564}
1565
1566
1567/* Prints a structure: name, fields, and methods.
1568 FIXME: Still incomplete. */
1569
1570static void
1571print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
1572{
1573 /* Print the name of the structure. */
1574 if (TYPE_NAME (node))
1575 {
1576 INDENT (spc);
1577 if (TREE_CODE (node) == RECORD_TYPE)
1578 pp_string (buffer, "struct ");
6374121b 1579 else if ((TREE_CODE (node) == UNION_TYPE
1580 || TREE_CODE (node) == QUAL_UNION_TYPE))
4ee9c684 1581 pp_string (buffer, "union ");
6374121b 1582
4ee9c684 1583 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
1584 }
1585
1586 /* Print the contents of the structure. */
1587 pp_newline (buffer);
1588 INDENT (spc);
1589 pp_character (buffer, '{');
1590 pp_newline (buffer);
1591
1592 /* Print the fields of the structure. */
1593 {
1594 tree tmp;
1595 tmp = TYPE_FIELDS (node);
1596 while (tmp)
1597 {
1598 /* Avoid to print recursively the structure. */
1599 /* FIXME : Not implemented correctly...,
1600 what about the case when we have a cycle in the contain graph? ...
1601 Maybe this could be solved by looking at the scope in which the
1602 structure was declared. */
1603 if (TREE_TYPE (tmp) != node
6374121b 1604 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
1605 && TREE_TYPE (TREE_TYPE (tmp)) != node))
4ee9c684 1606 {
1607 print_declaration (buffer, tmp, spc+2, flags);
1608 pp_newline (buffer);
1609 }
4ee9c684 1610 tmp = TREE_CHAIN (tmp);
1611 }
1612 }
1613 INDENT (spc);
1614 pp_character (buffer, '}');
1615}
1616
1617/* Return the priority of the operator OP.
1618
1619 From lowest to highest precedence with either left-to-right (L-R)
1620 or right-to-left (R-L) associativity]:
1621
1622 1 [L-R] ,
1623 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
1624 3 [R-L] ?:
1625 4 [L-R] ||
1626 5 [L-R] &&
1627 6 [L-R] |
1628 7 [L-R] ^
1629 8 [L-R] &
1630 9 [L-R] == !=
1631 10 [L-R] < <= > >=
1632 11 [L-R] << >>
1633 12 [L-R] + -
1634 13 [L-R] * / %
1635 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
1636 15 [L-R] fn() [] -> .
1637
1638 unary +, - and * have higher precedence than the corresponding binary
1639 operators. */
1640
1641static int
1642op_prio (tree op)
1643{
1644 if (op == NULL)
1645 return 9999;
1646
1647 switch (TREE_CODE (op))
1648 {
1649 case TREE_LIST:
1650 case COMPOUND_EXPR:
1651 case BIND_EXPR:
1652 return 1;
1653
1654 case MODIFY_EXPR:
1655 case INIT_EXPR:
1656 return 2;
1657
1658 case COND_EXPR:
1659 return 3;
1660
1661 case TRUTH_OR_EXPR:
1662 case TRUTH_ORIF_EXPR:
1663 return 4;
1664
1665 case TRUTH_AND_EXPR:
1666 case TRUTH_ANDIF_EXPR:
1667 return 5;
1668
1669 case BIT_IOR_EXPR:
1670 return 6;
1671
1672 case BIT_XOR_EXPR:
1673 case TRUTH_XOR_EXPR:
1674 return 7;
1675
1676 case BIT_AND_EXPR:
1677 return 8;
1678
1679 case EQ_EXPR:
1680 case NE_EXPR:
1681 return 9;
1682
318a728f 1683 case UNLT_EXPR:
1684 case UNLE_EXPR:
1685 case UNGT_EXPR:
1686 case UNGE_EXPR:
1687 case UNEQ_EXPR:
1688 case LTGT_EXPR:
1689 case ORDERED_EXPR:
1690 case UNORDERED_EXPR:
4ee9c684 1691 case LT_EXPR:
1692 case LE_EXPR:
1693 case GT_EXPR:
1694 case GE_EXPR:
1695 return 10;
1696
1697 case LSHIFT_EXPR:
1698 case RSHIFT_EXPR:
1699 case LROTATE_EXPR:
1700 case RROTATE_EXPR:
1701 return 11;
1702
1703 case PLUS_EXPR:
1704 case MINUS_EXPR:
1705 return 12;
1706
1707 case MULT_EXPR:
1708 case TRUNC_DIV_EXPR:
1709 case CEIL_DIV_EXPR:
1710 case FLOOR_DIV_EXPR:
1711 case ROUND_DIV_EXPR:
1712 case RDIV_EXPR:
1713 case EXACT_DIV_EXPR:
1714 case TRUNC_MOD_EXPR:
1715 case CEIL_MOD_EXPR:
1716 case FLOOR_MOD_EXPR:
1717 case ROUND_MOD_EXPR:
1718 return 13;
1719
1720 case TRUTH_NOT_EXPR:
1721 case BIT_NOT_EXPR:
1722 case POSTINCREMENT_EXPR:
1723 case POSTDECREMENT_EXPR:
1724 case PREINCREMENT_EXPR:
1725 case PREDECREMENT_EXPR:
1726 case NEGATE_EXPR:
b056d812 1727 case ALIGN_INDIRECT_REF:
1728 case MISALIGNED_INDIRECT_REF:
4ee9c684 1729 case INDIRECT_REF:
1730 case ADDR_EXPR:
1731 case FLOAT_EXPR:
1732 case NOP_EXPR:
1733 case CONVERT_EXPR:
1734 case FIX_TRUNC_EXPR:
1735 case FIX_CEIL_EXPR:
1736 case FIX_FLOOR_EXPR:
1737 case FIX_ROUND_EXPR:
1738 case TARGET_EXPR:
1739 return 14;
1740
1741 case CALL_EXPR:
1742 case ARRAY_REF:
6374121b 1743 case ARRAY_RANGE_REF:
4ee9c684 1744 case COMPONENT_REF:
1745 return 15;
1746
1747 /* Special expressions. */
1748 case MIN_EXPR:
1749 case MAX_EXPR:
1750 case ABS_EXPR:
1751 case REALPART_EXPR:
1752 case IMAGPART_EXPR:
1753 return 16;
1754
1755 case SAVE_EXPR:
1756 case NON_LVALUE_EXPR:
1757 return op_prio (TREE_OPERAND (op, 0));
1758
1759 default:
1760 /* Return an arbitrarily high precedence to avoid surrounding single
1761 VAR_DECLs in ()s. */
1762 return 9999;
1763 }
1764}
1765
1766
1767/* Return the symbol associated with operator OP. */
1768
1769static const char *
1770op_symbol (tree op)
1771{
8c0963c4 1772 gcc_assert (op);
4ee9c684 1773
1774 switch (TREE_CODE (op))
1775 {
1776 case MODIFY_EXPR:
1777 return "=";
1778
1779 case TRUTH_OR_EXPR:
1780 case TRUTH_ORIF_EXPR:
1781 return "||";
1782
1783 case TRUTH_AND_EXPR:
1784 case TRUTH_ANDIF_EXPR:
1785 return "&&";
1786
1787 case BIT_IOR_EXPR:
1788 return "|";
1789
1790 case TRUTH_XOR_EXPR:
1791 case BIT_XOR_EXPR:
1792 return "^";
1793
1794 case ADDR_EXPR:
1795 case BIT_AND_EXPR:
1796 return "&";
1797
318a728f 1798 case ORDERED_EXPR:
1799 return "ord";
1800 case UNORDERED_EXPR:
1801 return "unord";
1802
4ee9c684 1803 case EQ_EXPR:
4ee9c684 1804 return "==";
318a728f 1805 case UNEQ_EXPR:
1806 return "u==";
4ee9c684 1807
1808 case NE_EXPR:
1809 return "!=";
1810
1811 case LT_EXPR:
4ee9c684 1812 return "<";
318a728f 1813 case UNLT_EXPR:
1814 return "u<";
4ee9c684 1815
1816 case LE_EXPR:
4ee9c684 1817 return "<=";
318a728f 1818 case UNLE_EXPR:
1819 return "u<=";
4ee9c684 1820
1821 case GT_EXPR:
4ee9c684 1822 return ">";
318a728f 1823 case UNGT_EXPR:
1824 return "u>";
4ee9c684 1825
1826 case GE_EXPR:
4ee9c684 1827 return ">=";
318a728f 1828 case UNGE_EXPR:
1829 return "u>=";
1830
1831 case LTGT_EXPR:
1832 return "<>";
4ee9c684 1833
1834 case LSHIFT_EXPR:
1835 return "<<";
1836
1837 case RSHIFT_EXPR:
1838 return ">>";
1839
1840 case PLUS_EXPR:
1841 return "+";
1842
1843 case NEGATE_EXPR:
1844 case MINUS_EXPR:
1845 return "-";
1846
1847 case BIT_NOT_EXPR:
1848 return "~";
1849
1850 case TRUTH_NOT_EXPR:
1851 return "!";
1852
1853 case MULT_EXPR:
1854 case INDIRECT_REF:
1855 return "*";
1856
b056d812 1857 case ALIGN_INDIRECT_REF:
1858 return "A*";
1859
1860 case MISALIGNED_INDIRECT_REF:
1861 return "M*";
1862
4ee9c684 1863 case TRUNC_DIV_EXPR:
153536df 1864 case RDIV_EXPR:
1865 return "/";
1866
4ee9c684 1867 case CEIL_DIV_EXPR:
153536df 1868 return "/[cl]";
1869
4ee9c684 1870 case FLOOR_DIV_EXPR:
153536df 1871 return "/[fl]";
1872
4ee9c684 1873 case ROUND_DIV_EXPR:
153536df 1874 return "/[rd]";
1875
4ee9c684 1876 case EXACT_DIV_EXPR:
153536df 1877 return "/[ex]";
4ee9c684 1878
1879 case TRUNC_MOD_EXPR:
153536df 1880 return "%";
1881
4ee9c684 1882 case CEIL_MOD_EXPR:
153536df 1883 return "%[cl]";
1884
4ee9c684 1885 case FLOOR_MOD_EXPR:
153536df 1886 return "%[fl]";
1887
4ee9c684 1888 case ROUND_MOD_EXPR:
153536df 1889 return "%[rd]";
4ee9c684 1890
1891 case PREDECREMENT_EXPR:
1892 return " --";
1893
1894 case PREINCREMENT_EXPR:
1895 return " ++";
1896
1897 case POSTDECREMENT_EXPR:
1898 return "-- ";
1899
1900 case POSTINCREMENT_EXPR:
1901 return "++ ";
1902
4ee9c684 1903 default:
1904 return "<<< ??? >>>";
1905 }
1906}
1907
1908/* Prints the name of a CALL_EXPR. */
1909
1910static void
1911print_call_name (pretty_printer *buffer, tree node)
1912{
1913 tree op0;
1914
8c0963c4 1915 gcc_assert (TREE_CODE (node) == CALL_EXPR);
4ee9c684 1916
1917 op0 = TREE_OPERAND (node, 0);
1918
1919 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
1920 op0 = TREE_OPERAND (op0, 0);
1921
1922 switch (TREE_CODE (op0))
1923 {
1924 case VAR_DECL:
1925 case PARM_DECL:
a1080ab2 1926 dump_function_name (buffer, op0);
4ee9c684 1927 break;
1928
1929 case ADDR_EXPR:
1930 case INDIRECT_REF:
1931 case NOP_EXPR:
1932 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1933 break;
1934
1935 case COND_EXPR:
1936 pp_string (buffer, "(");
1937 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1938 pp_string (buffer, ") ? ");
1939 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
1940 pp_string (buffer, " : ");
1941 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
1942 break;
1943
1944 case COMPONENT_REF:
1945 /* The function is a pointer contained in a structure. */
1946 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
1947 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
a1080ab2 1948 dump_function_name (buffer, TREE_OPERAND (op0, 1));
4ee9c684 1949 else
1950 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1951 /* else
1952 We can have several levels of structures and a function
1953 pointer inside. This is not implemented yet... */
1954 /* NIY;*/
1955 break;
1956
1957 case ARRAY_REF:
1958 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
a1080ab2 1959 dump_function_name (buffer, TREE_OPERAND (op0, 0));
4ee9c684 1960 else
1961 dump_generic_node (buffer, op0, 0, 0, false);
1962 break;
1963
1964 case SSA_NAME:
215e2f1d 1965 case OBJ_TYPE_REF:
4ee9c684 1966 dump_generic_node (buffer, op0, 0, 0, false);
1967 break;
1968
1969 default:
1970 NIY;
1971 }
1972}
1973
1974/* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
1975
1976static void
1977pretty_print_string (pretty_printer *buffer, const char *str)
1978{
1979 if (str == NULL)
1980 return;
1981
1982 while (*str)
1983 {
1984 switch (str[0])
1985 {
1986 case '\b':
1987 pp_string (buffer, "\\b");
1988 break;
1989
1990 case '\f':
1991 pp_string (buffer, "\\f");
1992 break;
1993
1994 case '\n':
1995 pp_string (buffer, "\\n");
1996 break;
1997
1998 case '\r':
1999 pp_string (buffer, "\\r");
2000 break;
2001
2002 case '\t':
2003 pp_string (buffer, "\\t");
2004 break;
2005
2006 case '\v':
2007 pp_string (buffer, "\\v");
2008 break;
2009
2010 case '\\':
2011 pp_string (buffer, "\\\\");
2012 break;
2013
2014 case '\"':
2015 pp_string (buffer, "\\\"");
2016 break;
2017
2018 case '\'':
2019 pp_string (buffer, "\\'");
2020 break;
2021
2022 case '\0':
2023 pp_string (buffer, "\\0");
2024 break;
2025
2026 case '\1':
2027 pp_string (buffer, "\\1");
2028 break;
2029
2030 case '\2':
2031 pp_string (buffer, "\\2");
2032 break;
2033
2034 case '\3':
2035 pp_string (buffer, "\\3");
2036 break;
2037
2038 case '\4':
2039 pp_string (buffer, "\\4");
2040 break;
2041
2042 case '\5':
2043 pp_string (buffer, "\\5");
2044 break;
2045
2046 case '\6':
2047 pp_string (buffer, "\\6");
2048 break;
2049
2050 case '\7':
2051 pp_string (buffer, "\\7");
2052 break;
2053
2054 default:
2055 pp_character (buffer, str[0]);
2056 break;
2057 }
2058 str++;
2059 }
2060}
2061
2062static void
2063maybe_init_pretty_print (FILE *file)
2064{
2065 if (!initialized)
2066 {
2067 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2068 pp_needs_newline (&buffer) = true;
2069 initialized = 1;
2070 }
2071
2072 buffer.buffer->stream = file;
2073}
2074
2075static void
2076newline_and_indent (pretty_printer *buffer, int spc)
2077{
2078 pp_newline (buffer);
2079 INDENT (spc);
2080}
2081
2082static void
2083dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2084{
1bd13ef1 2085 tree use;
43daa21e 2086 use_operand_p use_p;
2087 def_operand_p def_p;
1bd13ef1 2088 use_operand_p kill_p;
43daa21e 2089 ssa_op_iter iter;
4ee9c684 2090
43daa21e 2091 FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
4ee9c684 2092 {
2093 pp_string (buffer, "# ");
43daa21e 2094 dump_generic_node (buffer, DEF_FROM_PTR (def_p),
2cf24776 2095 spc + 2, flags, false);
2096 pp_string (buffer, " = V_MAY_DEF <");
43daa21e 2097 dump_generic_node (buffer, USE_FROM_PTR (use_p),
2cf24776 2098 spc + 2, flags, false);
2099 pp_string (buffer, ">;");
2100 newline_and_indent (buffer, spc);
2101 }
2102
1bd13ef1 2103 FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter)
2cf24776 2104 {
1bd13ef1 2105 pp_string (buffer, "# ");
2106 dump_generic_node (buffer, DEF_FROM_PTR (def_p),
2107 spc + 2, flags, false);
2108 pp_string (buffer, " = V_MUST_DEF <");
2109 dump_generic_node (buffer, USE_FROM_PTR (kill_p),
2110 spc + 2, flags, false);
4ee9c684 2111 pp_string (buffer, ">;");
2112 newline_and_indent (buffer, spc);
2113 }
2114
43daa21e 2115 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)
4ee9c684 2116 {
4ee9c684 2117 pp_string (buffer, "# VUSE <");
43daa21e 2118 dump_generic_node (buffer, use, spc + 2, flags, false);
4ee9c684 2119 pp_string (buffer, ">;");
2120 newline_and_indent (buffer, spc);
2121 }
2122}
2123
2124/* Dumps basic block BB to FILE with details described by FLAGS and
2125 indented by INDENT spaces. */
2126
2127void
2128dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2129{
2130 maybe_init_pretty_print (file);
2131 dumping_stmts = true;
2132 dump_generic_bb_buff (&buffer, bb, indent, flags);
2133 pp_flush (&buffer);
2134}
2135
2136/* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2137 spaces and details described by flags. */
2138
2139static void
2140dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2141{
2142 edge e;
2143 tree stmt;
cd665a06 2144 edge_iterator ei;
4ee9c684 2145
2146 if (flags & TDF_BLOCKS)
2147 {
2148 INDENT (indent);
2149 pp_string (buffer, "# BLOCK ");
2150 pp_decimal_int (buffer, bb->index);
2151
2152 if (flags & TDF_LINENO)
2153 {
2154 block_stmt_iterator bsi;
2155
2156 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2157 if (get_lineno (bsi_stmt (bsi)) != -1)
2158 {
2159 pp_string (buffer, ", starting at line ");
2160 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2161 break;
2162 }
2163 }
2164 newline_and_indent (buffer, indent);
2165
2166 pp_string (buffer, "# PRED:");
2167 pp_write_text_to_stream (buffer);
cd665a06 2168 FOR_EACH_EDGE (e, ei, bb->preds)
2169 if (flags & TDF_SLIM)
4ee9c684 2170 {
2171 pp_string (buffer, " ");
2172 if (e->src == ENTRY_BLOCK_PTR)
2173 pp_string (buffer, "ENTRY");
2174 else
2175 pp_decimal_int (buffer, e->src->index);
2176 }
2177 else
2178 dump_edge_info (buffer->buffer->stream, e, 0);
2179 pp_newline (buffer);
2180 }
2181 else
2182 {
2183 stmt = first_stmt (bb);
2184 if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
2185 {
2186 INDENT (indent - 2);
2187 pp_string (buffer, "<bb ");
2188 pp_decimal_int (buffer, bb->index);
2189 pp_string (buffer, ">:");
2190 pp_newline (buffer);
2191 }
2192 }
020c749b 2193 pp_write_text_to_stream (buffer);
2194 check_bb_profile (bb, buffer->buffer->stream);
4ee9c684 2195}
2196
2197/* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2198 spaces. */
2199
2200static void
2201dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
2202{
2203 edge e;
cd665a06 2204 edge_iterator ei;
4ee9c684 2205
2206 INDENT (indent);
2207 pp_string (buffer, "# SUCC:");
2208 pp_write_text_to_stream (buffer);
cd665a06 2209 FOR_EACH_EDGE (e, ei, bb->succs)
4ee9c684 2210 if (flags & TDF_SLIM)
2211 {
2212 pp_string (buffer, " ");
2213 if (e->dest == EXIT_BLOCK_PTR)
2214 pp_string (buffer, "EXIT");
2215 else
2216 pp_decimal_int (buffer, e->dest->index);
2217 }
2218 else
2219 dump_edge_info (buffer->buffer->stream, e, 1);
2220 pp_newline (buffer);
2221}
2222
2223/* Dumps phi nodes of basic block BB to buffer BUFFER with details described by
2224 FLAGS indented by INDENT spaces. */
2225
2226static void
2227dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
2228{
2229 tree phi = phi_nodes (bb);
2230 if (!phi)
2231 return;
2232
04f8eea3 2233 for (; phi; phi = PHI_CHAIN (phi))
4ee9c684 2234 {
2235 if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
2236 {
2237 INDENT (indent);
2238 pp_string (buffer, "# ");
2239 dump_generic_node (buffer, phi, indent, flags, false);
2240 pp_newline (buffer);
2241 }
2242 }
2243}
2244
2245/* Dump jump to basic block BB that is represented implicitly in the cfg
2246 to BUFFER. */
2247
2248static void
2249pp_cfg_jump (pretty_printer *buffer, basic_block bb)
2250{
2251 tree stmt;
2252
2253 stmt = first_stmt (bb);
2254
2255 pp_string (buffer, "goto <bb ");
2256 pp_decimal_int (buffer, bb->index);
2257 pp_string (buffer, ">");
2258 if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
2259 {
2260 pp_string (buffer, " (");
2261 dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
2262 pp_string (buffer, ")");
2263 }
2264 pp_semicolon (buffer);
2265}
2266
2267/* Dump edges represented implicitly in basic block BB to BUFFER, indented
2268 by INDENT spaces, with details given by FLAGS. */
2269
2270static void
815540dd 2271dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
2272 int flags)
4ee9c684 2273{
2274 edge e;
cd665a06 2275 edge_iterator ei;
4ee9c684 2276
2277 /* If there is a fallthru edge, we may need to add an artificial goto to the
2278 dump. */
cd665a06 2279 FOR_EACH_EDGE (e, ei, bb->succs)
4ee9c684 2280 if (e->flags & EDGE_FALLTHRU)
2281 break;
2282 if (e && e->dest != bb->next_bb)
2283 {
2284 INDENT (indent);
815540dd 2285
7bd3dcc4 2286 if ((flags & TDF_LINENO)
2287#ifdef USE_MAPPED_LOCATION
2288 && e->goto_locus != UNKNOWN_LOCATION
2289#else
2290 && e->goto_locus
2291#endif
2292 )
815540dd 2293 {
7bd3dcc4 2294 expanded_location goto_xloc;
2295#ifdef USE_MAPPED_LOCATION
2296 goto_xloc = expand_location (e->goto_locus);
2297#else
2298 goto_xloc = *e->goto_locus;
2299#endif
815540dd 2300 pp_character (buffer, '[');
7bd3dcc4 2301 if (goto_xloc.file)
815540dd 2302 {
7bd3dcc4 2303 pp_string (buffer, goto_xloc.file);
815540dd 2304 pp_string (buffer, " : ");
2305 }
7bd3dcc4 2306 pp_decimal_int (buffer, goto_xloc.line);
815540dd 2307 pp_string (buffer, "] ");
2308 }
2309
4ee9c684 2310 pp_cfg_jump (buffer, e->dest);
2311 pp_newline (buffer);
2312 }
2313}
2314
2315/* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2316 indented by INDENT spaces. */
2317
2318static void
2319dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
2320 int indent, int flags)
2321{
2322 block_stmt_iterator bsi;
2323 tree stmt;
2324 int label_indent = indent - 2;
2325
2326 if (label_indent < 0)
2327 label_indent = 0;
2328
2329 dump_bb_header (buffer, bb, indent, flags);
2330
2331 if (bb_ann (bb))
2332 dump_phi_nodes (buffer, bb, indent, flags);
b27ac6b5 2333
4ee9c684 2334 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2335 {
2336 int curr_indent;
2337
2338 stmt = bsi_stmt (bsi);
2339
2340 curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
2341
2342 INDENT (curr_indent);
2343 dump_generic_node (buffer, stmt, curr_indent, flags, true);
2344 pp_newline (buffer);
2345 }
2346
815540dd 2347 dump_implicit_edges (buffer, bb, indent, flags);
4ee9c684 2348
2349 if (flags & TDF_BLOCKS)
2350 dump_bb_end (buffer, bb, indent, flags);
2351}
Mirror of https://gcc.gnu.org/git/gcc.git