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