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