?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* tree-core.h (enum omp_clause_code): Add OMP_CLAUSE_DEFAULTMAP.
[official-gcc.git] / gcc / tree-pretty-print.c
blobe0d27df95c0728f86a6d846edbf757765becbb69
1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2015 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 "alias.h"
26 #include "symtab.h"
27 #include "tree.h"
28 #include "stor-layout.h"
29 #include "hard-reg-set.h"
30 #include "function.h"
31 #include "rtl.h"
32 #include "flags.h"
33 #include "insn-config.h"
34 #include "expmed.h"
35 #include "dojump.h"
36 #include "explow.h"
37 #include "calls.h"
38 #include "emit-rtl.h"
39 #include "varasm.h"
40 #include "stmt.h"
41 #include "expr.h"
42 #include "tree-pretty-print.h"
43 #include "gimple-expr.h"
44 #include "predict.h"
45 #include "cgraph.h"
46 #include "langhooks.h"
47 #include "tree-iterator.h"
48 #include "tree-chrec.h"
49 #include "dumpfile.h"
50 #include "value-prof.h"
51 #include "wide-int-print.h"
52 #include "internal-fn.h"
53 #include "gomp-constants.h"
54
55 /* Local functions, macros and variables. */
56 static const char *op_symbol (const_tree);
57 static void pretty_print_string (pretty_printer *, const char*);
58 static void newline_and_indent (pretty_printer *, int);
59 static void maybe_init_pretty_print (FILE *);
60 static void print_struct_decl (pretty_printer *, const_tree, int, int);
61 static void do_niy (pretty_printer *, const_tree);
62
63 #define INDENT(SPACE) do { \
64 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
65
66 #define NIY do_niy (pp, node)
67
68 static pretty_printer *tree_pp;
69
70 /* Try to print something for an unknown tree code. */
71
72 static void
73 do_niy (pretty_printer *pp, const_tree node)
74 {
75 int i, len;
76
77 pp_string (pp, "<<< Unknown tree: ");
78 pp_string (pp, get_tree_code_name (TREE_CODE (node)));
79
80 if (EXPR_P (node))
81 {
82 len = TREE_OPERAND_LENGTH (node);
83 for (i = 0; i < len; ++i)
84 {
85 newline_and_indent (pp, 2);
86 dump_generic_node (pp, TREE_OPERAND (node, i), 2, 0, false);
87 }
88 }
89
90 pp_string (pp, " >>>");
91 }
92
93 /* Debugging function to print out a generic expression. */
94
95 DEBUG_FUNCTION void
96 debug_generic_expr (tree t)
97 {
98 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
99 fprintf (stderr, "\n");
100 }
101
102 /* Debugging function to print out a generic statement. */
103
104 DEBUG_FUNCTION void
105 debug_generic_stmt (tree t)
106 {
107 print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
108 fprintf (stderr, "\n");
109 }
110
111 /* Debugging function to print out a chain of trees . */
112
113 DEBUG_FUNCTION void
114 debug_tree_chain (tree t)
115 {
116 hash_set<tree> seen;
117
118 while (t)
119 {
120 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
121 fprintf (stderr, " ");
122 t = TREE_CHAIN (t);
123 if (seen.add (t))
124 {
125 fprintf (stderr, "... [cycled back to ");
126 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
127 fprintf (stderr, "]");
128 break;
129 }
130 }
131 fprintf (stderr, "\n");
132 }
133
134 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
135 void
136 print_generic_decl (FILE *file, tree decl, int flags)
137 {
138 maybe_init_pretty_print (file);
139 print_declaration (tree_pp, decl, 2, flags);
140 pp_write_text_to_stream (tree_pp);
141 }
142
143 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
144 to show in the dump. See TDF_* in dumpfile.h. */
145
146 void
147 print_generic_stmt (FILE *file, tree t, int flags)
148 {
149 maybe_init_pretty_print (file);
150 dump_generic_node (tree_pp, t, 0, flags, true);
151 pp_newline_and_flush (tree_pp);
152 }
153
154 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
155 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
156 INDENT spaces. */
157
158 void
159 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
160 {
161 int i;
162
163 maybe_init_pretty_print (file);
164
165 for (i = 0; i < indent; i++)
166 pp_space (tree_pp);
167 dump_generic_node (tree_pp, t, indent, flags, true);
168 pp_newline_and_flush (tree_pp);
169 }
170
171 /* Print a single expression T on file FILE. FLAGS specifies details to show
172 in the dump. See TDF_* in dumpfile.h. */
173
174 void
175 print_generic_expr (FILE *file, tree t, int flags)
176 {
177 maybe_init_pretty_print (file);
178 dump_generic_node (tree_pp, t, 0, flags, false);
179 pp_flush (tree_pp);
180 }
181
182 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
183 in FLAGS. */
184
185 static void
186 dump_decl_name (pretty_printer *pp, tree node, int flags)
187 {
188 if (DECL_NAME (node))
189 {
190 if ((flags & TDF_ASMNAME) && DECL_ASSEMBLER_NAME_SET_P (node))
191 pp_tree_identifier (pp, DECL_ASSEMBLER_NAME (node));
192 else
193 pp_tree_identifier (pp, DECL_NAME (node));
194 }
195 if ((flags & TDF_UID) || DECL_NAME (node) == NULL_TREE)
196 {
197 if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)
198 pp_printf (pp, "L.%d", (int) LABEL_DECL_UID (node));
199 else if (TREE_CODE (node) == DEBUG_EXPR_DECL)
200 {
201 if (flags & TDF_NOUID)
202 pp_string (pp, "D#xxxx");
203 else
204 pp_printf (pp, "D#%i", DEBUG_TEMP_UID (node));
205 }
206 else
207 {
208 char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
209 if (flags & TDF_NOUID)
210 pp_printf (pp, "%c.xxxx", c);
211 else
212 pp_printf (pp, "%c.%u", c, DECL_UID (node));
213 }
214 }
215 if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node))
216 {
217 if (flags & TDF_NOUID)
218 pp_printf (pp, "ptD.xxxx");
219 else
220 pp_printf (pp, "ptD.%u", DECL_PT_UID (node));
221 }
222 }
223
224 /* Like the above, but used for pretty printing function calls. */
225
226 static void
227 dump_function_name (pretty_printer *pp, tree node, int flags)
228 {
229 if (CONVERT_EXPR_P (node))
230 node = TREE_OPERAND (node, 0);
231 if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)
232 pp_string (pp, lang_hooks.decl_printable_name (node, 1));
233 else
234 dump_decl_name (pp, node, flags);
235 }
236
237 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
238 FLAGS are as in dump_generic_node. */
239
240 static void
241 dump_function_declaration (pretty_printer *pp, tree node,
242 int spc, int flags)
243 {
244 bool wrote_arg = false;
245 tree arg;
246
247 pp_space (pp);
248 pp_left_paren (pp);
249
250 /* Print the argument types. */
251 arg = TYPE_ARG_TYPES (node);
252 while (arg && arg != void_list_node && arg != error_mark_node)
253 {
254 if (wrote_arg)
255 {
256 pp_comma (pp);
257 pp_space (pp);
258 }
259 wrote_arg = true;
260 dump_generic_node (pp, TREE_VALUE (arg), spc, flags, false);
261 arg = TREE_CHAIN (arg);
262 }
263
264 /* Drop the trailing void_type_node if we had any previous argument. */
265 if (arg == void_list_node && !wrote_arg)
266 pp_string (pp, "void");
267 /* Properly dump vararg function types. */
268 else if (!arg && wrote_arg)
269 pp_string (pp, ", ...");
270 /* Avoid printing any arg for unprototyped functions. */
271
272 pp_right_paren (pp);
273 }
274
275 /* Dump the domain associated with an array. */
276
277 static void
278 dump_array_domain (pretty_printer *pp, tree domain, int spc, int flags)
279 {
280 pp_left_bracket (pp);
281 if (domain)
282 {
283 tree min = TYPE_MIN_VALUE (domain);
284 tree max = TYPE_MAX_VALUE (domain);
285
286 if (min && max
287 && integer_zerop (min)
288 && tree_fits_shwi_p (max))
289 pp_wide_integer (pp, tree_to_shwi (max) + 1);
290 else
291 {
292 if (min)
293 dump_generic_node (pp, min, spc, flags, false);
294 pp_colon (pp);
295 if (max)
296 dump_generic_node (pp, max, spc, flags, false);
297 }
298 }
299 else
300 pp_string (pp, "<unknown>");
301 pp_right_bracket (pp);
302 }
303
304
305 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
306 dump_generic_node. */
307
308 static void
309 dump_omp_clause (pretty_printer *pp, tree clause, int spc, int flags)
310 {
311 const char *name;
312
313 switch (OMP_CLAUSE_CODE (clause))
314 {
315 case OMP_CLAUSE_PRIVATE:
316 name = "private";
317 goto print_remap;
318 case OMP_CLAUSE_SHARED:
319 name = "shared";
320 goto print_remap;
321 case OMP_CLAUSE_FIRSTPRIVATE:
322 name = "firstprivate";
323 goto print_remap;
324 case OMP_CLAUSE_LASTPRIVATE:
325 name = "lastprivate";
326 goto print_remap;
327 case OMP_CLAUSE_COPYIN:
328 name = "copyin";
329 goto print_remap;
330 case OMP_CLAUSE_COPYPRIVATE:
331 name = "copyprivate";
332 goto print_remap;
333 case OMP_CLAUSE_UNIFORM:
334 name = "uniform";
335 goto print_remap;
336 case OMP_CLAUSE__LOOPTEMP_:
337 name = "_looptemp_";
338 goto print_remap;
339 case OMP_CLAUSE_DEVICE_RESIDENT:
340 name = "device_resident";
341 goto print_remap;
342 case OMP_CLAUSE_USE_DEVICE:
343 name = "use_device";
344 goto print_remap;
345 print_remap:
346 pp_string (pp, name);
347 pp_left_paren (pp);
348 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
349 spc, flags, false);
350 pp_right_paren (pp);
351 break;
352
353 case OMP_CLAUSE_REDUCTION:
354 pp_string (pp, "reduction(");
355 if (OMP_CLAUSE_REDUCTION_CODE (clause) != ERROR_MARK)
356 {
357 pp_string (pp,
358 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
359 pp_colon (pp);
360 }
361 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
362 spc, flags, false);
363 pp_right_paren (pp);
364 break;
365
366 case OMP_CLAUSE_IF:
367 pp_string (pp, "if(");
368 dump_generic_node (pp, OMP_CLAUSE_IF_EXPR (clause),
369 spc, flags, false);
370 pp_right_paren (pp);
371 break;
372
373 case OMP_CLAUSE_NUM_THREADS:
374 pp_string (pp, "num_threads(");
375 dump_generic_node (pp, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
376 spc, flags, false);
377 pp_right_paren (pp);
378 break;
379
380 case OMP_CLAUSE__CILK_FOR_COUNT_:
381 pp_string (pp, "_Cilk_for_count_(");
382 dump_generic_node (pp, OMP_CLAUSE_OPERAND (clause, 0),
383 spc, flags, false);
384 pp_right_paren (pp);
385 break;
386
387 case OMP_CLAUSE_NOWAIT:
388 pp_string (pp, "nowait");
389 break;
390 case OMP_CLAUSE_ORDERED:
391 pp_string (pp, "ordered");
392 if (OMP_CLAUSE_ORDERED_EXPR (clause))
393 {
394 pp_left_paren (pp);
395 dump_generic_node (pp, OMP_CLAUSE_ORDERED_EXPR (clause),
396 spc, flags, false);
397 pp_right_paren (pp);
398 }
399 break;
400
401 case OMP_CLAUSE_DEFAULT:
402 pp_string (pp, "default(");
403 switch (OMP_CLAUSE_DEFAULT_KIND (clause))
404 {
405 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
406 break;
407 case OMP_CLAUSE_DEFAULT_SHARED:
408 pp_string (pp, "shared");
409 break;
410 case OMP_CLAUSE_DEFAULT_NONE:
411 pp_string (pp, "none");
412 break;
413 case OMP_CLAUSE_DEFAULT_PRIVATE:
414 pp_string (pp, "private");
415 break;
416 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
417 pp_string (pp, "firstprivate");
418 break;
419 default:
420 gcc_unreachable ();
421 }
422 pp_right_paren (pp);
423 break;
424
425 case OMP_CLAUSE_SCHEDULE:
426 pp_string (pp, "schedule(");
427 if (OMP_CLAUSE_SCHEDULE_SIMD (clause))
428 pp_string (pp, "simd:");
429 switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
430 {
431 case OMP_CLAUSE_SCHEDULE_STATIC:
432 pp_string (pp, "static");
433 break;
434 case OMP_CLAUSE_SCHEDULE_DYNAMIC:
435 pp_string (pp, "dynamic");
436 break;
437 case OMP_CLAUSE_SCHEDULE_GUIDED:
438 pp_string (pp, "guided");
439 break;
440 case OMP_CLAUSE_SCHEDULE_RUNTIME:
441 pp_string (pp, "runtime");
442 break;
443 case OMP_CLAUSE_SCHEDULE_AUTO:
444 pp_string (pp, "auto");
445 break;
446 case OMP_CLAUSE_SCHEDULE_CILKFOR:
447 pp_string (pp, "cilk-for grain");
448 break;
449 default:
450 gcc_unreachable ();
451 }
452 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
453 {
454 pp_comma (pp);
455 dump_generic_node (pp, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
456 spc, flags, false);
457 }
458 pp_right_paren (pp);
459 break;
460
461 case OMP_CLAUSE_UNTIED:
462 pp_string (pp, "untied");
463 break;
464
465 case OMP_CLAUSE_COLLAPSE:
466 pp_string (pp, "collapse(");
467 dump_generic_node (pp, OMP_CLAUSE_COLLAPSE_EXPR (clause),
468 spc, flags, false);
469 pp_right_paren (pp);
470 break;
471
472 case OMP_CLAUSE_FINAL:
473 pp_string (pp, "final(");
474 dump_generic_node (pp, OMP_CLAUSE_FINAL_EXPR (clause),
475 spc, flags, false);
476 pp_right_paren (pp);
477 break;
478
479 case OMP_CLAUSE_MERGEABLE:
480 pp_string (pp, "mergeable");
481 break;
482
483 case OMP_CLAUSE_LINEAR:
484 pp_string (pp, "linear(");
485 switch (OMP_CLAUSE_LINEAR_KIND (clause))
486 {
487 case OMP_CLAUSE_LINEAR_DEFAULT:
488 break;
489 case OMP_CLAUSE_LINEAR_REF:
490 pp_string (pp, "ref(");
491 break;
492 case OMP_CLAUSE_LINEAR_VAL:
493 pp_string (pp, "val(");
494 break;
495 case OMP_CLAUSE_LINEAR_UVAL:
496 pp_string (pp, "uval(");
497 break;
498 default:
499 gcc_unreachable ();
500 }
501 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
502 spc, flags, false);
503 if (OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
504 pp_right_paren (pp);
505 pp_colon (pp);
506 dump_generic_node (pp, OMP_CLAUSE_LINEAR_STEP (clause),
507 spc, flags, false);
508 pp_right_paren (pp);
509 break;
510
511 case OMP_CLAUSE_ALIGNED:
512 pp_string (pp, "aligned(");
513 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
514 spc, flags, false);
515 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause))
516 {
517 pp_colon (pp);
518 dump_generic_node (pp, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause),
519 spc, flags, false);
520 }
521 pp_right_paren (pp);
522 break;
523
524 case OMP_CLAUSE_DEPEND:
525 pp_string (pp, "depend(");
526 switch (OMP_CLAUSE_DEPEND_KIND (clause))
527 {
528 case OMP_CLAUSE_DEPEND_IN:
529 pp_string (pp, "in");
530 break;
531 case OMP_CLAUSE_DEPEND_OUT:
532 pp_string (pp, "out");
533 break;
534 case OMP_CLAUSE_DEPEND_INOUT:
535 pp_string (pp, "inout");
536 break;
537 case OMP_CLAUSE_DEPEND_SOURCE:
538 pp_string (pp, "source)");
539 return;
540 default:
541 gcc_unreachable ();
542 }
543 pp_colon (pp);
544 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
545 spc, flags, false);
546 pp_right_paren (pp);
547 break;
548
549 case OMP_CLAUSE_MAP:
550 pp_string (pp, "map(");
551 switch (OMP_CLAUSE_MAP_KIND (clause))
552 {
553 case GOMP_MAP_ALLOC:
554 case GOMP_MAP_POINTER:
555 pp_string (pp, "alloc");
556 break;
557 case GOMP_MAP_TO:
558 case GOMP_MAP_TO_PSET:
559 pp_string (pp, "to");
560 break;
561 case GOMP_MAP_FROM:
562 pp_string (pp, "from");
563 break;
564 case GOMP_MAP_TOFROM:
565 pp_string (pp, "tofrom");
566 break;
567 case GOMP_MAP_FORCE_ALLOC:
568 pp_string (pp, "force_alloc");
569 break;
570 case GOMP_MAP_FORCE_TO:
571 pp_string (pp, "force_to");
572 break;
573 case GOMP_MAP_FORCE_FROM:
574 pp_string (pp, "force_from");
575 break;
576 case GOMP_MAP_FORCE_TOFROM:
577 pp_string (pp, "force_tofrom");
578 break;
579 case GOMP_MAP_FORCE_PRESENT:
580 pp_string (pp, "force_present");
581 break;
582 case GOMP_MAP_FORCE_DEALLOC:
583 pp_string (pp, "delete");
584 break;
585 case GOMP_MAP_FORCE_DEVICEPTR:
586 pp_string (pp, "force_deviceptr");
587 break;
588 case GOMP_MAP_ALWAYS_TO:
589 pp_string (pp, "always,to");
590 break;
591 case GOMP_MAP_ALWAYS_FROM:
592 pp_string (pp, "always,from");
593 break;
594 case GOMP_MAP_ALWAYS_TOFROM:
595 pp_string (pp, "always,tofrom");
596 break;
597 case GOMP_MAP_RELEASE:
598 pp_string (pp, "release");
599 break;
600 default:
601 gcc_unreachable ();
602 }
603 pp_colon (pp);
604 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
605 spc, flags, false);
606 print_clause_size:
607 if (OMP_CLAUSE_SIZE (clause))
608 {
609 if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
610 && OMP_CLAUSE_MAP_KIND (clause) == GOMP_MAP_POINTER)
611 pp_string (pp, " [pointer assign, bias: ");
612 else if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
613 && OMP_CLAUSE_MAP_KIND (clause) == GOMP_MAP_TO_PSET)
614 pp_string (pp, " [pointer set, len: ");
615 else
616 pp_string (pp, " [len: ");
617 dump_generic_node (pp, OMP_CLAUSE_SIZE (clause),
618 spc, flags, false);
619 pp_right_bracket (pp);
620 }
621 pp_right_paren (pp);
622 break;
623
624 case OMP_CLAUSE_FROM:
625 pp_string (pp, "from(");
626 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
627 spc, flags, false);
628 goto print_clause_size;
629
630 case OMP_CLAUSE_TO:
631 pp_string (pp, "to(");
632 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
633 spc, flags, false);
634 goto print_clause_size;
635
636 case OMP_CLAUSE__CACHE_:
637 pp_string (pp, "(");
638 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
639 spc, flags, false);
640 goto print_clause_size;
641
642 case OMP_CLAUSE_NUM_TEAMS:
643 pp_string (pp, "num_teams(");
644 dump_generic_node (pp, OMP_CLAUSE_NUM_TEAMS_EXPR (clause),
645 spc, flags, false);
646 pp_right_paren (pp);
647 break;
648
649 case OMP_CLAUSE_THREAD_LIMIT:
650 pp_string (pp, "thread_limit(");
651 dump_generic_node (pp, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause),
652 spc, flags, false);
653 pp_right_paren (pp);
654 break;
655
656 case OMP_CLAUSE_DEVICE:
657 pp_string (pp, "device(");
658 dump_generic_node (pp, OMP_CLAUSE_DEVICE_ID (clause),
659 spc, flags, false);
660 pp_right_paren (pp);
661 break;
662
663 case OMP_CLAUSE_DIST_SCHEDULE:
664 pp_string (pp, "dist_schedule(static");
665 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause))
666 {
667 pp_comma (pp);
668 dump_generic_node (pp,
669 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause),
670 spc, flags, false);
671 }
672 pp_right_paren (pp);
673 break;
674
675 case OMP_CLAUSE_PROC_BIND:
676 pp_string (pp, "proc_bind(");
677 switch (OMP_CLAUSE_PROC_BIND_KIND (clause))
678 {
679 case OMP_CLAUSE_PROC_BIND_MASTER:
680 pp_string (pp, "master");
681 break;
682 case OMP_CLAUSE_PROC_BIND_CLOSE:
683 pp_string (pp, "close");
684 break;
685 case OMP_CLAUSE_PROC_BIND_SPREAD:
686 pp_string (pp, "spread");
687 break;
688 default:
689 gcc_unreachable ();
690 }
691 pp_right_paren (pp);
692 break;
693
694 case OMP_CLAUSE_SAFELEN:
695 pp_string (pp, "safelen(");
696 dump_generic_node (pp, OMP_CLAUSE_SAFELEN_EXPR (clause),
697 spc, flags, false);
698 pp_right_paren (pp);
699 break;
700
701 case OMP_CLAUSE_SIMDLEN:
702 pp_string (pp, "simdlen(");
703 dump_generic_node (pp, OMP_CLAUSE_SIMDLEN_EXPR (clause),
704 spc, flags, false);
705 pp_right_paren (pp);
706 break;
707
708 case OMP_CLAUSE_PRIORITY:
709 pp_string (pp, "priority(");
710 dump_generic_node (pp, OMP_CLAUSE_PRIORITY_EXPR (clause),
711 spc, flags, false);
712 pp_right_paren (pp);
713 break;
714
715 case OMP_CLAUSE_GRAINSIZE:
716 pp_string (pp, "grainsize(");
717 dump_generic_node (pp, OMP_CLAUSE_GRAINSIZE_EXPR (clause),
718 spc, flags, false);
719 pp_right_paren (pp);
720 break;
721
722 case OMP_CLAUSE_NUM_TASKS:
723 pp_string (pp, "num_tasks(");
724 dump_generic_node (pp, OMP_CLAUSE_NUM_TASKS_EXPR (clause),
725 spc, flags, false);
726 pp_right_paren (pp);
727 break;
728
729 case OMP_CLAUSE_HINT:
730 pp_string (pp, "hint(");
731 dump_generic_node (pp, OMP_CLAUSE_HINT_EXPR (clause),
732 spc, flags, false);
733 pp_right_paren (pp);
734 break;
735
736 case OMP_CLAUSE_DEFAULTMAP:
737 pp_string (pp, "defaultmap(tofrom:scalar)");
738 break;
739
740 case OMP_CLAUSE__SIMDUID_:
741 pp_string (pp, "_simduid_(");
742 dump_generic_node (pp, OMP_CLAUSE__SIMDUID__DECL (clause),
743 spc, flags, false);
744 pp_right_paren (pp);
745 break;
746
747 case OMP_CLAUSE_GANG:
748 pp_string (pp, "gang");
749 if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE)
750 {
751 pp_string (pp, "(num: ");
752 dump_generic_node (pp, OMP_CLAUSE_GANG_EXPR (clause),
753 spc, flags, false);
754 }
755 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE)
756 {
757 if (OMP_CLAUSE_GANG_EXPR (clause) == NULL_TREE)
758 pp_left_paren (pp);
759 else
760 pp_space (pp);
761 pp_string (pp, "static:");
762 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause)
763 == integer_minus_one_node)
764 pp_character (pp, '*');
765 else
766 dump_generic_node (pp, OMP_CLAUSE_GANG_STATIC_EXPR (clause),
767 spc, flags, false);
768 }
769 if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE
770 || OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE)
771 pp_right_paren (pp);
772 break;
773
774 case OMP_CLAUSE_ASYNC:
775 pp_string (pp, "async");
776 if (OMP_CLAUSE_ASYNC_EXPR (clause))
777 {
778 pp_character(pp, '(');
779 dump_generic_node (pp, OMP_CLAUSE_ASYNC_EXPR (clause),
780 spc, flags, false);
781 pp_character(pp, ')');
782 }
783 break;
784
785 case OMP_CLAUSE_AUTO:
786 case OMP_CLAUSE_SEQ:
787 pp_string (pp, omp_clause_code_name[OMP_CLAUSE_CODE (clause)]);
788 break;
789
790 case OMP_CLAUSE_WAIT:
791 pp_string (pp, "wait(");
792 dump_generic_node (pp, OMP_CLAUSE_WAIT_EXPR (clause),
793 spc, flags, false);
794 pp_character(pp, ')');
795 break;
796
797 case OMP_CLAUSE_WORKER:
798 pp_string (pp, "worker");
799 if (OMP_CLAUSE_WORKER_EXPR (clause) != NULL_TREE)
800 {
801 pp_left_paren (pp);
802 dump_generic_node (pp, OMP_CLAUSE_WORKER_EXPR (clause),
803 spc, flags, false);
804 pp_right_paren (pp);
805 }
806 break;
807
808 case OMP_CLAUSE_VECTOR:
809 pp_string (pp, "vector");
810 if (OMP_CLAUSE_VECTOR_EXPR (clause) != NULL_TREE)
811 {
812 pp_left_paren (pp);
813 dump_generic_node (pp, OMP_CLAUSE_VECTOR_EXPR (clause),
814 spc, flags, false);
815 pp_right_paren (pp);
816 }
817 break;
818
819 case OMP_CLAUSE_NUM_GANGS:
820 pp_string (pp, "num_gangs(");
821 dump_generic_node (pp, OMP_CLAUSE_NUM_GANGS_EXPR (clause),
822 spc, flags, false);
823 pp_character (pp, ')');
824 break;
825
826 case OMP_CLAUSE_NUM_WORKERS:
827 pp_string (pp, "num_workers(");
828 dump_generic_node (pp, OMP_CLAUSE_NUM_WORKERS_EXPR (clause),
829 spc, flags, false);
830 pp_character (pp, ')');
831 break;
832
833 case OMP_CLAUSE_VECTOR_LENGTH:
834 pp_string (pp, "vector_length(");
835 dump_generic_node (pp, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause),
836 spc, flags, false);
837 pp_character (pp, ')');
838 break;
839
840 case OMP_CLAUSE_INBRANCH:
841 pp_string (pp, "inbranch");
842 break;
843 case OMP_CLAUSE_NOTINBRANCH:
844 pp_string (pp, "notinbranch");
845 break;
846 case OMP_CLAUSE_FOR:
847 pp_string (pp, "for");
848 break;
849 case OMP_CLAUSE_PARALLEL:
850 pp_string (pp, "parallel");
851 break;
852 case OMP_CLAUSE_SECTIONS:
853 pp_string (pp, "sections");
854 break;
855 case OMP_CLAUSE_TASKGROUP:
856 pp_string (pp, "taskgroup");
857 break;
858 case OMP_CLAUSE_NOGROUP:
859 pp_string (pp, "nogroup");
860 break;
861 case OMP_CLAUSE_THREADS:
862 pp_string (pp, "threads");
863 break;
864 case OMP_CLAUSE_SIMD:
865 pp_string (pp, "simd");
866 break;
867 case OMP_CLAUSE_INDEPENDENT:
868 pp_string (pp, "independent");
869 break;
870
871 default:
872 /* Should never happen. */
873 dump_generic_node (pp, clause, spc, flags, false);
874 break;
875 }
876 }
877
878
879 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
880 dump_generic_node. */
881
882 void
883 dump_omp_clauses (pretty_printer *pp, tree clause, int spc, int flags)
884 {
885 if (clause == NULL)
886 return;
887
888 pp_space (pp);
889 while (1)
890 {
891 dump_omp_clause (pp, clause, spc, flags);
892 clause = OMP_CLAUSE_CHAIN (clause);
893 if (clause == NULL)
894 return;
895 pp_space (pp);
896 }
897 }
898
899
900 /* Dump location LOC to PP. */
901
902 void
903 dump_location (pretty_printer *pp, location_t loc)
904 {
905 expanded_location xloc = expand_location (loc);
906
907 pp_left_bracket (pp);
908 if (xloc.file)
909 {
910 pp_string (pp, xloc.file);
911 pp_string (pp, ":");
912 }
913 pp_decimal_int (pp, xloc.line);
914 pp_colon (pp);
915 pp_decimal_int (pp, xloc.column);
916 pp_string (pp, "] ");
917 }
918
919
920 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
921 dump_generic_node. */
922
923 static void
924 dump_block_node (pretty_printer *pp, tree block, int spc, int flags)
925 {
926 tree t;
927
928 pp_printf (pp, "BLOCK #%d ", BLOCK_NUMBER (block));
929
930 if (flags & TDF_ADDRESS)
931 pp_printf (pp, "[%p] ", (void *) block);
932
933 if (BLOCK_ABSTRACT (block))
934 pp_string (pp, "[abstract] ");
935
936 if (TREE_ASM_WRITTEN (block))
937 pp_string (pp, "[written] ");
938
939 if (flags & TDF_SLIM)
940 return;
941
942 if (BLOCK_SOURCE_LOCATION (block))
943 dump_location (pp, BLOCK_SOURCE_LOCATION (block));
944
945 newline_and_indent (pp, spc + 2);
946
947 if (BLOCK_SUPERCONTEXT (block))
948 {
949 pp_string (pp, "SUPERCONTEXT: ");
950 dump_generic_node (pp, BLOCK_SUPERCONTEXT (block), 0,
951 flags | TDF_SLIM, false);
952 newline_and_indent (pp, spc + 2);
953 }
954
955 if (BLOCK_SUBBLOCKS (block))
956 {
957 pp_string (pp, "SUBBLOCKS: ");
958 for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
959 {
960 dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
961 pp_space (pp);
962 }
963 newline_and_indent (pp, spc + 2);
964 }
965
966 if (BLOCK_CHAIN (block))
967 {
968 pp_string (pp, "SIBLINGS: ");
969 for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))
970 {
971 dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
972 pp_space (pp);
973 }
974 newline_and_indent (pp, spc + 2);
975 }
976
977 if (BLOCK_VARS (block))
978 {
979 pp_string (pp, "VARS: ");
980 for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
981 {
982 dump_generic_node (pp, t, 0, flags, false);
983 pp_space (pp);
984 }
985 newline_and_indent (pp, spc + 2);
986 }
987
988 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block)) > 0)
989 {
990 unsigned i;
991 vec<tree, va_gc> *nlv = BLOCK_NONLOCALIZED_VARS (block);
992
993 pp_string (pp, "NONLOCALIZED_VARS: ");
994 FOR_EACH_VEC_ELT (*nlv, i, t)
995 {
996 dump_generic_node (pp, t, 0, flags, false);
997 pp_space (pp);
998 }
999 newline_and_indent (pp, spc + 2);
1000 }
1001
1002 if (BLOCK_ABSTRACT_ORIGIN (block))
1003 {
1004 pp_string (pp, "ABSTRACT_ORIGIN: ");
1005 dump_generic_node (pp, BLOCK_ABSTRACT_ORIGIN (block), 0,
1006 flags | TDF_SLIM, false);
1007 newline_and_indent (pp, spc + 2);
1008 }
1009
1010 if (BLOCK_FRAGMENT_ORIGIN (block))
1011 {
1012 pp_string (pp, "FRAGMENT_ORIGIN: ");
1013 dump_generic_node (pp, BLOCK_FRAGMENT_ORIGIN (block), 0,
1014 flags | TDF_SLIM, false);
1015 newline_and_indent (pp, spc + 2);
1016 }
1017
1018 if (BLOCK_FRAGMENT_CHAIN (block))
1019 {
1020 pp_string (pp, "FRAGMENT_CHAIN: ");
1021 for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))
1022 {
1023 dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
1024 pp_space (pp);
1025 }
1026 newline_and_indent (pp, spc + 2);
1027 }
1028 }
1029
1030
1031 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1032 indent. FLAGS specifies details to show in the dump (see TDF_* in
1033 dumpfile.h). If IS_STMT is true, the object printed is considered
1034 to be a statement and it is terminated by ';' if appropriate. */
1035
1036 int
1037 dump_generic_node (pretty_printer *pp, tree node, int spc, int flags,
1038 bool is_stmt)
1039 {
1040 tree type;
1041 tree op0, op1;
1042 const char *str;
1043 bool is_expr;
1044 enum tree_code code;
1045
1046 if (node == NULL_TREE)
1047 return spc;
1048
1049 is_expr = EXPR_P (node);
1050
1051 if (is_stmt && (flags & TDF_STMTADDR))
1052 pp_printf (pp, "<&%p> ", (void *)node);
1053
1054 if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
1055 dump_location (pp, EXPR_LOCATION (node));
1056
1057 code = TREE_CODE (node);
1058 switch (code)
1059 {
1060 case ERROR_MARK:
1061 pp_string (pp, "<<< error >>>");
1062 break;
1063
1064 case IDENTIFIER_NODE:
1065 pp_tree_identifier (pp, node);
1066 break;
1067
1068 case TREE_LIST:
1069 while (node && node != error_mark_node)
1070 {
1071 if (TREE_PURPOSE (node))
1072 {
1073 dump_generic_node (pp, TREE_PURPOSE (node), spc, flags, false);
1074 pp_space (pp);
1075 }
1076 dump_generic_node (pp, TREE_VALUE (node), spc, flags, false);
1077 node = TREE_CHAIN (node);
1078 if (node && TREE_CODE (node) == TREE_LIST)
1079 {
1080 pp_comma (pp);
1081 pp_space (pp);
1082 }
1083 }
1084 break;
1085
1086 case TREE_BINFO:
1087 dump_generic_node (pp, BINFO_TYPE (node), spc, flags, false);
1088 break;
1089
1090 case TREE_VEC:
1091 {
1092 size_t i;
1093 if (TREE_VEC_LENGTH (node) > 0)
1094 {
1095 size_t len = TREE_VEC_LENGTH (node);
1096 for (i = 0; i < len - 1; i++)
1097 {
1098 dump_generic_node (pp, TREE_VEC_ELT (node, i), spc, flags,
1099 false);
1100 pp_comma (pp);
1101 pp_space (pp);
1102 }
1103 dump_generic_node (pp, TREE_VEC_ELT (node, len - 1), spc,
1104 flags, false);
1105 }
1106 }
1107 break;
1108
1109 case VOID_TYPE:
1110 case POINTER_BOUNDS_TYPE:
1111 case INTEGER_TYPE:
1112 case REAL_TYPE:
1113 case FIXED_POINT_TYPE:
1114 case COMPLEX_TYPE:
1115 case VECTOR_TYPE:
1116 case ENUMERAL_TYPE:
1117 case BOOLEAN_TYPE:
1118 {
1119 unsigned int quals = TYPE_QUALS (node);
1120 enum tree_code_class tclass;
1121
1122 if (quals & TYPE_QUAL_ATOMIC)
1123 pp_string (pp, "atomic ");
1124 if (quals & TYPE_QUAL_CONST)
1125 pp_string (pp, "const ");
1126 else if (quals & TYPE_QUAL_VOLATILE)
1127 pp_string (pp, "volatile ");
1128 else if (quals & TYPE_QUAL_RESTRICT)
1129 pp_string (pp, "restrict ");
1130
1131 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
1132 {
1133 pp_string (pp, "<address-space-");
1134 pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
1135 pp_string (pp, "> ");
1136 }
1137
1138 tclass = TREE_CODE_CLASS (TREE_CODE (node));
1139
1140 if (tclass == tcc_declaration)
1141 {
1142 if (DECL_NAME (node))
1143 dump_decl_name (pp, node, flags);
1144 else
1145 pp_string (pp, "<unnamed type decl>");
1146 }
1147 else if (tclass == tcc_type)
1148 {
1149 if (TYPE_NAME (node))
1150 {
1151 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
1152 pp_tree_identifier (pp, TYPE_NAME (node));
1153 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
1154 && DECL_NAME (TYPE_NAME (node)))
1155 dump_decl_name (pp, TYPE_NAME (node), flags);
1156 else
1157 pp_string (pp, "<unnamed type>");
1158 }
1159 else if (TREE_CODE (node) == VECTOR_TYPE)
1160 {
1161 pp_string (pp, "vector");
1162 pp_left_paren (pp);
1163 pp_wide_integer (pp, TYPE_VECTOR_SUBPARTS (node));
1164 pp_string (pp, ") ");
1165 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1166 }
1167 else if (TREE_CODE (node) == INTEGER_TYPE)
1168 {
1169 if (TYPE_PRECISION (node) == CHAR_TYPE_SIZE)
1170 pp_string (pp, (TYPE_UNSIGNED (node)
1171 ? "unsigned char"
1172 : "signed char"));
1173 else if (TYPE_PRECISION (node) == SHORT_TYPE_SIZE)
1174 pp_string (pp, (TYPE_UNSIGNED (node)
1175 ? "unsigned short"
1176 : "signed short"));
1177 else if (TYPE_PRECISION (node) == INT_TYPE_SIZE)
1178 pp_string (pp, (TYPE_UNSIGNED (node)
1179 ? "unsigned int"
1180 : "signed int"));
1181 else if (TYPE_PRECISION (node) == LONG_TYPE_SIZE)
1182 pp_string (pp, (TYPE_UNSIGNED (node)
1183 ? "unsigned long"
1184 : "signed long"));
1185 else if (TYPE_PRECISION (node) == LONG_LONG_TYPE_SIZE)
1186 pp_string (pp, (TYPE_UNSIGNED (node)
1187 ? "unsigned long long"
1188 : "signed long long"));
1189 else if (TYPE_PRECISION (node) >= CHAR_TYPE_SIZE
1190 && exact_log2 (TYPE_PRECISION (node)) != -1)
1191 {
1192 pp_string (pp, (TYPE_UNSIGNED (node) ? "uint" : "int"));
1193 pp_decimal_int (pp, TYPE_PRECISION (node));
1194 pp_string (pp, "_t");
1195 }
1196 else
1197 {
1198 pp_string (pp, (TYPE_UNSIGNED (node)
1199 ? "<unnamed-unsigned:"
1200 : "<unnamed-signed:"));
1201 pp_decimal_int (pp, TYPE_PRECISION (node));
1202 pp_greater (pp);
1203 }
1204 }
1205 else if (TREE_CODE (node) == COMPLEX_TYPE)
1206 {
1207 pp_string (pp, "__complex__ ");
1208 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1209 }
1210 else if (TREE_CODE (node) == REAL_TYPE)
1211 {
1212 pp_string (pp, "<float:");
1213 pp_decimal_int (pp, TYPE_PRECISION (node));
1214 pp_greater (pp);
1215 }
1216 else if (TREE_CODE (node) == FIXED_POINT_TYPE)
1217 {
1218 pp_string (pp, "<fixed-point-");
1219 pp_string (pp, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
1220 pp_decimal_int (pp, TYPE_PRECISION (node));
1221 pp_greater (pp);
1222 }
1223 else if (TREE_CODE (node) == VOID_TYPE)
1224 pp_string (pp, "void");
1225 else
1226 pp_string (pp, "<unnamed type>");
1227 }
1228 break;
1229 }
1230
1231 case POINTER_TYPE:
1232 case REFERENCE_TYPE:
1233 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
1234
1235 if (TREE_TYPE (node) == NULL)
1236 {
1237 pp_string (pp, str);
1238 pp_string (pp, "<null type>");
1239 }
1240 else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
1241 {
1242 tree fnode = TREE_TYPE (node);
1243
1244 dump_generic_node (pp, TREE_TYPE (fnode), spc, flags, false);
1245 pp_space (pp);
1246 pp_left_paren (pp);
1247 pp_string (pp, str);
1248 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
1249 dump_decl_name (pp, TYPE_NAME (node), flags);
1250 else if (flags & TDF_NOUID)
1251 pp_printf (pp, "<Txxxx>");
1252 else
1253 pp_printf (pp, "<T%x>", TYPE_UID (node));
1254
1255 pp_right_paren (pp);
1256 dump_function_declaration (pp, fnode, spc, flags);
1257 }
1258 else
1259 {
1260 unsigned int quals = TYPE_QUALS (node);
1261
1262 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1263 pp_space (pp);
1264 pp_string (pp, str);
1265
1266 if (quals & TYPE_QUAL_CONST)
1267 pp_string (pp, " const");
1268 if (quals & TYPE_QUAL_VOLATILE)
1269 pp_string (pp, " volatile");
1270 if (quals & TYPE_QUAL_RESTRICT)
1271 pp_string (pp, " restrict");
1272
1273 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
1274 {
1275 pp_string (pp, " <address-space-");
1276 pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
1277 pp_greater (pp);
1278 }
1279
1280 if (TYPE_REF_CAN_ALIAS_ALL (node))
1281 pp_string (pp, " {ref-all}");
1282 }
1283 break;
1284
1285 case OFFSET_TYPE:
1286 NIY;
1287 break;
1288
1289 case MEM_REF:
1290 {
1291 if (integer_zerop (TREE_OPERAND (node, 1))
1292 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1293 infer them and MEM_ATTR caching will share MEM_REFs
1294 with differently-typed op0s. */
1295 && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
1296 /* Released SSA_NAMES have no TREE_TYPE. */
1297 && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
1298 /* Same pointer types, but ignoring POINTER_TYPE vs.
1299 REFERENCE_TYPE. */
1300 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
1301 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
1302 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
1303 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
1304 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
1305 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
1306 /* Same value types ignoring qualifiers. */
1307 && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
1308 == TYPE_MAIN_VARIANT
1309 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))
1310 && (!(flags & TDF_ALIAS)
1311 || MR_DEPENDENCE_CLIQUE (node) == 0))
1312 {
1313 if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
1314 {
1315 pp_star (pp);
1316 dump_generic_node (pp, TREE_OPERAND (node, 0),
1317 spc, flags, false);
1318 }
1319 else
1320 dump_generic_node (pp,
1321 TREE_OPERAND (TREE_OPERAND (node, 0), 0),
1322 spc, flags, false);
1323 }
1324 else
1325 {
1326 tree ptype;
1327
1328 pp_string (pp, "MEM[");
1329 pp_left_paren (pp);
1330 ptype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1)));
1331 dump_generic_node (pp, ptype,
1332 spc, flags | TDF_SLIM, false);
1333 pp_right_paren (pp);
1334 dump_generic_node (pp, TREE_OPERAND (node, 0),
1335 spc, flags, false);
1336 if (!integer_zerop (TREE_OPERAND (node, 1)))
1337 {
1338 pp_string (pp, " + ");
1339 dump_generic_node (pp, TREE_OPERAND (node, 1),
1340 spc, flags, false);
1341 }
1342 if ((flags & TDF_ALIAS)
1343 && MR_DEPENDENCE_CLIQUE (node) != 0)
1344 {
1345 pp_string (pp, " clique ");
1346 pp_unsigned_wide_integer (pp, MR_DEPENDENCE_CLIQUE (node));
1347 pp_string (pp, " base ");
1348 pp_unsigned_wide_integer (pp, MR_DEPENDENCE_BASE (node));
1349 }
1350 pp_right_bracket (pp);
1351 }
1352 break;
1353 }
1354
1355 case TARGET_MEM_REF:
1356 {
1357 const char *sep = "";
1358 tree tmp;
1359
1360 pp_string (pp, "MEM[");
1361
1362 if (TREE_CODE (TMR_BASE (node)) == ADDR_EXPR)
1363 {
1364 pp_string (pp, sep);
1365 sep = ", ";
1366 pp_string (pp, "symbol: ");
1367 dump_generic_node (pp, TREE_OPERAND (TMR_BASE (node), 0),
1368 spc, flags, false);
1369 }
1370 else
1371 {
1372 pp_string (pp, sep);
1373 sep = ", ";
1374 pp_string (pp, "base: ");
1375 dump_generic_node (pp, TMR_BASE (node), spc, flags, false);
1376 }
1377 tmp = TMR_INDEX2 (node);
1378 if (tmp)
1379 {
1380 pp_string (pp, sep);
1381 sep = ", ";
1382 pp_string (pp, "base: ");
1383 dump_generic_node (pp, tmp, spc, flags, false);
1384 }
1385 tmp = TMR_INDEX (node);
1386 if (tmp)
1387 {
1388 pp_string (pp, sep);
1389 sep = ", ";
1390 pp_string (pp, "index: ");
1391 dump_generic_node (pp, tmp, spc, flags, false);
1392 }
1393 tmp = TMR_STEP (node);
1394 if (tmp)
1395 {
1396 pp_string (pp, sep);
1397 sep = ", ";
1398 pp_string (pp, "step: ");
1399 dump_generic_node (pp, tmp, spc, flags, false);
1400 }
1401 tmp = TMR_OFFSET (node);
1402 if (tmp)
1403 {
1404 pp_string (pp, sep);
1405 sep = ", ";
1406 pp_string (pp, "offset: ");
1407 dump_generic_node (pp, tmp, spc, flags, false);
1408 }
1409 pp_right_bracket (pp);
1410 }
1411 break;
1412
1413 case ARRAY_TYPE:
1414 {
1415 tree tmp;
1416
1417 /* Print the innermost component type. */
1418 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
1419 tmp = TREE_TYPE (tmp))
1420 ;
1421 dump_generic_node (pp, tmp, spc, flags, false);
1422
1423 /* Print the dimensions. */
1424 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
1425 dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
1426 break;
1427 }
1428
1429 case RECORD_TYPE:
1430 case UNION_TYPE:
1431 case QUAL_UNION_TYPE:
1432 {
1433 unsigned int quals = TYPE_QUALS (node);
1434
1435 if (quals & TYPE_QUAL_ATOMIC)
1436 pp_string (pp, "atomic ");
1437 if (quals & TYPE_QUAL_CONST)
1438 pp_string (pp, "const ");
1439 if (quals & TYPE_QUAL_VOLATILE)
1440 pp_string (pp, "volatile ");
1441
1442 /* Print the name of the structure. */
1443 if (TREE_CODE (node) == RECORD_TYPE)
1444 pp_string (pp, "struct ");
1445 else if (TREE_CODE (node) == UNION_TYPE)
1446 pp_string (pp, "union ");
1447
1448 if (TYPE_NAME (node))
1449 dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
1450 else if (!(flags & TDF_SLIM))
1451 /* FIXME: If we eliminate the 'else' above and attempt
1452 to show the fields for named types, we may get stuck
1453 following a cycle of pointers to structs. The alleged
1454 self-reference check in print_struct_decl will not detect
1455 cycles involving more than one pointer or struct type. */
1456 print_struct_decl (pp, node, spc, flags);
1457 break;
1458 }
1459
1460 case LANG_TYPE:
1461 NIY;
1462 break;
1463
1464 case INTEGER_CST:
1465 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
1466 {
1467 /* In the case of a pointer, one may want to divide by the
1468 size of the pointed-to type. Unfortunately, this not
1469 straightforward. The C front-end maps expressions
1470
1471 (int *) 5
1472 int *p; (p + 5)
1473
1474 in such a way that the two INTEGER_CST nodes for "5" have
1475 different values but identical types. In the latter
1476 case, the 5 is multiplied by sizeof (int) in c-common.c
1477 (pointer_int_sum) to convert it to a byte address, and
1478 yet the type of the node is left unchanged. Argh. What
1479 is consistent though is that the number value corresponds
1480 to bytes (UNITS) offset.
1481
1482 NB: Neither of the following divisors can be trivially
1483 used to recover the original literal:
1484
1485 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1486 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1487 pp_wide_integer (pp, TREE_INT_CST_LOW (node));
1488 pp_string (pp, "B"); /* pseudo-unit */
1489 }
1490 else if (tree_fits_shwi_p (node))
1491 pp_wide_integer (pp, tree_to_shwi (node));
1492 else if (tree_fits_uhwi_p (node))
1493 pp_unsigned_wide_integer (pp, tree_to_uhwi (node));
1494 else
1495 {
1496 wide_int val = node;
1497
1498 if (wi::neg_p (val, TYPE_SIGN (TREE_TYPE (node))))
1499 {
1500 pp_minus (pp);
1501 val = -val;
1502 }
1503 print_hex (val, pp_buffer (pp)->digit_buffer);
1504 pp_string (pp, pp_buffer (pp)->digit_buffer);
1505 }
1506 if (TREE_OVERFLOW (node))
1507 pp_string (pp, "(OVF)");
1508 break;
1509
1510 case REAL_CST:
1511 /* Code copied from print_node. */
1512 {
1513 REAL_VALUE_TYPE d;
1514 if (TREE_OVERFLOW (node))
1515 pp_string (pp, " overflow");
1516
1517 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
1518 d = TREE_REAL_CST (node);
1519 if (REAL_VALUE_ISINF (d))
1520 pp_string (pp, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
1521 else if (REAL_VALUE_ISNAN (d))
1522 pp_string (pp, " Nan");
1523 else
1524 {
1525 char string[100];
1526 real_to_decimal (string, &d, sizeof (string), 0, 1);
1527 pp_string (pp, string);
1528 }
1529 #else
1530 {
1531 HOST_WIDE_INT i;
1532 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
1533 pp_string (pp, "0x");
1534 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
1535 output_formatted_integer (pp, "%02x", *p++);
1536 }
1537 #endif
1538 break;
1539 }
1540
1541 case FIXED_CST:
1542 {
1543 char string[100];
1544 fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
1545 pp_string (pp, string);
1546 break;
1547 }
1548
1549 case COMPLEX_CST:
1550 pp_string (pp, "__complex__ (");
1551 dump_generic_node (pp, TREE_REALPART (node), spc, flags, false);
1552 pp_string (pp, ", ");
1553 dump_generic_node (pp, TREE_IMAGPART (node), spc, flags, false);
1554 pp_right_paren (pp);
1555 break;
1556
1557 case STRING_CST:
1558 pp_string (pp, "\"");
1559 pretty_print_string (pp, TREE_STRING_POINTER (node));
1560 pp_string (pp, "\"");
1561 break;
1562
1563 case VECTOR_CST:
1564 {
1565 unsigned i;
1566 pp_string (pp, "{ ");
1567 for (i = 0; i < VECTOR_CST_NELTS (node); ++i)
1568 {
1569 if (i != 0)
1570 pp_string (pp, ", ");
1571 dump_generic_node (pp, VECTOR_CST_ELT (node, i),
1572 spc, flags, false);
1573 }
1574 pp_string (pp, " }");
1575 }
1576 break;
1577
1578 case FUNCTION_TYPE:
1579 case METHOD_TYPE:
1580 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1581 pp_space (pp);
1582 if (TREE_CODE (node) == METHOD_TYPE)
1583 {
1584 if (TYPE_METHOD_BASETYPE (node))
1585 dump_decl_name (pp, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
1586 flags);
1587 else
1588 pp_string (pp, "<null method basetype>");
1589 pp_colon_colon (pp);
1590 }
1591 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
1592 dump_decl_name (pp, TYPE_NAME (node), flags);
1593 else if (flags & TDF_NOUID)
1594 pp_printf (pp, "<Txxxx>");
1595 else
1596 pp_printf (pp, "<T%x>", TYPE_UID (node));
1597 dump_function_declaration (pp, node, spc, flags);
1598 break;
1599
1600 case FUNCTION_DECL:
1601 case CONST_DECL:
1602 dump_decl_name (pp, node, flags);
1603 break;
1604
1605 case LABEL_DECL:
1606 if (DECL_NAME (node))
1607 dump_decl_name (pp, node, flags);
1608 else if (LABEL_DECL_UID (node) != -1)
1609 pp_printf (pp, "<L%d>", (int) LABEL_DECL_UID (node));
1610 else
1611 {
1612 if (flags & TDF_NOUID)
1613 pp_string (pp, "<D.xxxx>");
1614 else
1615 pp_printf (pp, "<D.%u>", DECL_UID (node));
1616 }
1617 break;
1618
1619 case TYPE_DECL:
1620 if (DECL_IS_BUILTIN (node))
1621 {
1622 /* Don't print the declaration of built-in types. */
1623 break;
1624 }
1625 if (DECL_NAME (node))
1626 dump_decl_name (pp, node, flags);
1627 else if (TYPE_NAME (TREE_TYPE (node)) != node)
1628 {
1629 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
1630 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
1631 && TYPE_METHODS (TREE_TYPE (node)))
1632 {
1633 /* The type is a c++ class: all structures have at least
1634 4 methods. */
1635 pp_string (pp, "class ");
1636 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1637 }
1638 else
1639 {
1640 pp_string (pp,
1641 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
1642 ? "union" : "struct "));
1643 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1644 }
1645 }
1646 else
1647 pp_string (pp, "<anon>");
1648 break;
1649
1650 case VAR_DECL:
1651 case PARM_DECL:
1652 case FIELD_DECL:
1653 case DEBUG_EXPR_DECL:
1654 case NAMESPACE_DECL:
1655 case NAMELIST_DECL:
1656 dump_decl_name (pp, node, flags);
1657 break;
1658
1659 case RESULT_DECL:
1660 pp_string (pp, "<retval>");
1661 break;
1662
1663 case COMPONENT_REF:
1664 op0 = TREE_OPERAND (node, 0);
1665 str = ".";
1666 if (op0
1667 && (TREE_CODE (op0) == INDIRECT_REF
1668 || (TREE_CODE (op0) == MEM_REF
1669 && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR
1670 && integer_zerop (TREE_OPERAND (op0, 1))
1671 /* Dump the types of INTEGER_CSTs explicitly, for we
1672 can't infer them and MEM_ATTR caching will share
1673 MEM_REFs with differently-typed op0s. */
1674 && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST
1675 /* Released SSA_NAMES have no TREE_TYPE. */
1676 && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE
1677 /* Same pointer types, but ignoring POINTER_TYPE vs.
1678 REFERENCE_TYPE. */
1679 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
1680 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))
1681 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0)))
1682 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1))))
1683 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0)))
1684 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1))))
1685 /* Same value types ignoring qualifiers. */
1686 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0))
1687 == TYPE_MAIN_VARIANT
1688 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))))
1689 && MR_DEPENDENCE_CLIQUE (op0) == 0)))
1690 {
1691 op0 = TREE_OPERAND (op0, 0);
1692 str = "->";
1693 }
1694 if (op_prio (op0) < op_prio (node))
1695 pp_left_paren (pp);
1696 dump_generic_node (pp, op0, spc, flags, false);
1697 if (op_prio (op0) < op_prio (node))
1698 pp_right_paren (pp);
1699 pp_string (pp, str);
1700 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1701 op0 = component_ref_field_offset (node);
1702 if (op0 && TREE_CODE (op0) != INTEGER_CST)
1703 {
1704 pp_string (pp, "{off: ");
1705 dump_generic_node (pp, op0, spc, flags, false);
1706 pp_right_brace (pp);
1707 }
1708 break;
1709
1710 case BIT_FIELD_REF:
1711 pp_string (pp, "BIT_FIELD_REF <");
1712 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
1713 pp_string (pp, ", ");
1714 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1715 pp_string (pp, ", ");
1716 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
1717 pp_greater (pp);
1718 break;
1719
1720 case ARRAY_REF:
1721 case ARRAY_RANGE_REF:
1722 op0 = TREE_OPERAND (node, 0);
1723 if (op_prio (op0) < op_prio (node))
1724 pp_left_paren (pp);
1725 dump_generic_node (pp, op0, spc, flags, false);
1726 if (op_prio (op0) < op_prio (node))
1727 pp_right_paren (pp);
1728 pp_left_bracket (pp);
1729 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1730 if (TREE_CODE (node) == ARRAY_RANGE_REF)
1731 pp_string (pp, " ...");
1732 pp_right_bracket (pp);
1733
1734 op0 = array_ref_low_bound (node);
1735 op1 = array_ref_element_size (node);
1736
1737 if (!integer_zerop (op0)
1738 || TREE_OPERAND (node, 2)
1739 || TREE_OPERAND (node, 3))
1740 {
1741 pp_string (pp, "{lb: ");
1742 dump_generic_node (pp, op0, spc, flags, false);
1743 pp_string (pp, " sz: ");
1744 dump_generic_node (pp, op1, spc, flags, false);
1745 pp_right_brace (pp);
1746 }
1747 break;
1748
1749 case CONSTRUCTOR:
1750 {
1751 unsigned HOST_WIDE_INT ix;
1752 tree field, val;
1753 bool is_struct_init = false;
1754 bool is_array_init = false;
1755 widest_int curidx;
1756 pp_left_brace (pp);
1757 if (TREE_CLOBBER_P (node))
1758 pp_string (pp, "CLOBBER");
1759 else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
1760 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
1761 is_struct_init = true;
1762 else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE
1763 && TYPE_DOMAIN (TREE_TYPE (node))
1764 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))
1765 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))))
1766 == INTEGER_CST)
1767 {
1768 tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)));
1769 is_array_init = true;
1770 curidx = wi::to_widest (minv);
1771 }
1772 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
1773 {
1774 if (field)
1775 {
1776 if (is_struct_init)
1777 {
1778 pp_dot (pp);
1779 dump_generic_node (pp, field, spc, flags, false);
1780 pp_equal (pp);
1781 }
1782 else if (is_array_init
1783 && (TREE_CODE (field) != INTEGER_CST
1784 || curidx != wi::to_widest (field)))
1785 {
1786 pp_left_bracket (pp);
1787 if (TREE_CODE (field) == RANGE_EXPR)
1788 {
1789 dump_generic_node (pp, TREE_OPERAND (field, 0), spc,
1790 flags, false);
1791 pp_string (pp, " ... ");
1792 dump_generic_node (pp, TREE_OPERAND (field, 1), spc,
1793 flags, false);
1794 if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST)
1795 curidx = wi::to_widest (TREE_OPERAND (field, 1));
1796 }
1797 else
1798 dump_generic_node (pp, field, spc, flags, false);
1799 if (TREE_CODE (field) == INTEGER_CST)
1800 curidx = wi::to_widest (field);
1801 pp_string (pp, "]=");
1802 }
1803 }
1804 if (is_array_init)
1805 curidx += 1;
1806 if (val && TREE_CODE (val) == ADDR_EXPR)
1807 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
1808 val = TREE_OPERAND (val, 0);
1809 if (val && TREE_CODE (val) == FUNCTION_DECL)
1810 dump_decl_name (pp, val, flags);
1811 else
1812 dump_generic_node (pp, val, spc, flags, false);
1813 if (ix != vec_safe_length (CONSTRUCTOR_ELTS (node)) - 1)
1814 {
1815 pp_comma (pp);
1816 pp_space (pp);
1817 }
1818 }
1819 pp_right_brace (pp);
1820 }
1821 break;
1822
1823 case COMPOUND_EXPR:
1824 {
1825 tree *tp;
1826 if (flags & TDF_SLIM)
1827 {
1828 pp_string (pp, "<COMPOUND_EXPR>");
1829 break;
1830 }
1831
1832 dump_generic_node (pp, TREE_OPERAND (node, 0),
1833 spc, flags, !(flags & TDF_SLIM));
1834 if (flags & TDF_SLIM)
1835 newline_and_indent (pp, spc);
1836 else
1837 {
1838 pp_comma (pp);
1839 pp_space (pp);
1840 }
1841
1842 for (tp = &TREE_OPERAND (node, 1);
1843 TREE_CODE (*tp) == COMPOUND_EXPR;
1844 tp = &TREE_OPERAND (*tp, 1))
1845 {
1846 dump_generic_node (pp, TREE_OPERAND (*tp, 0),
1847 spc, flags, !(flags & TDF_SLIM));
1848 if (flags & TDF_SLIM)
1849 newline_and_indent (pp, spc);
1850 else
1851 {
1852 pp_comma (pp);
1853 pp_space (pp);
1854 }
1855 }
1856
1857 dump_generic_node (pp, *tp, spc, flags, !(flags & TDF_SLIM));
1858 }
1859 break;
1860
1861 case STATEMENT_LIST:
1862 {
1863 tree_stmt_iterator si;
1864 bool first = true;
1865
1866 if (flags & TDF_SLIM)
1867 {
1868 pp_string (pp, "<STATEMENT_LIST>");
1869 break;
1870 }
1871
1872 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1873 {
1874 if (!first)
1875 newline_and_indent (pp, spc);
1876 else
1877 first = false;
1878 dump_generic_node (pp, tsi_stmt (si), spc, flags, true);
1879 }
1880 }
1881 break;
1882
1883 case MODIFY_EXPR:
1884 case INIT_EXPR:
1885 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags,
1886 false);
1887 pp_space (pp);
1888 pp_equal (pp);
1889 pp_space (pp);
1890 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags,
1891 false);
1892 break;
1893
1894 case TARGET_EXPR:
1895 pp_string (pp, "TARGET_EXPR <");
1896 dump_generic_node (pp, TARGET_EXPR_SLOT (node), spc, flags, false);
1897 pp_comma (pp);
1898 pp_space (pp);
1899 dump_generic_node (pp, TARGET_EXPR_INITIAL (node), spc, flags, false);
1900 pp_greater (pp);
1901 break;
1902
1903 case DECL_EXPR:
1904 print_declaration (pp, DECL_EXPR_DECL (node), spc, flags);
1905 is_stmt = false;
1906 break;
1907
1908 case COND_EXPR:
1909 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1910 {
1911 pp_string (pp, "if (");
1912 dump_generic_node (pp, COND_EXPR_COND (node), spc, flags, false);
1913 pp_right_paren (pp);
1914 /* The lowered cond_exprs should always be printed in full. */
1915 if (COND_EXPR_THEN (node)
1916 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1917 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1918 && COND_EXPR_ELSE (node)
1919 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1920 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1921 {
1922 pp_space (pp);
1923 dump_generic_node (pp, COND_EXPR_THEN (node),
1924 0, flags, true);
1925 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1926 {
1927 pp_string (pp, " else ");
1928 dump_generic_node (pp, COND_EXPR_ELSE (node),
1929 0, flags, true);
1930 }
1931 }
1932 else if (!(flags & TDF_SLIM))
1933 {
1934 /* Output COND_EXPR_THEN. */
1935 if (COND_EXPR_THEN (node))
1936 {
1937 newline_and_indent (pp, spc+2);
1938 pp_left_brace (pp);
1939 newline_and_indent (pp, spc+4);
1940 dump_generic_node (pp, COND_EXPR_THEN (node), spc+4,
1941 flags, true);
1942 newline_and_indent (pp, spc+2);
1943 pp_right_brace (pp);
1944 }
1945
1946 /* Output COND_EXPR_ELSE. */
1947 if (COND_EXPR_ELSE (node)
1948 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1949 {
1950 newline_and_indent (pp, spc);
1951 pp_string (pp, "else");
1952 newline_and_indent (pp, spc+2);
1953 pp_left_brace (pp);
1954 newline_and_indent (pp, spc+4);
1955 dump_generic_node (pp, COND_EXPR_ELSE (node), spc+4,
1956 flags, true);
1957 newline_and_indent (pp, spc+2);
1958 pp_right_brace (pp);
1959 }
1960 }
1961 is_expr = false;
1962 }
1963 else
1964 {
1965 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
1966 pp_space (pp);
1967 pp_question (pp);
1968 pp_space (pp);
1969 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1970 pp_space (pp);
1971 pp_colon (pp);
1972 pp_space (pp);
1973 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
1974 }
1975 break;
1976
1977 case BIND_EXPR:
1978 pp_left_brace (pp);
1979 if (!(flags & TDF_SLIM))
1980 {
1981 if (BIND_EXPR_VARS (node))
1982 {
1983 pp_newline (pp);
1984
1985 for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0))
1986 {
1987 print_declaration (pp, op0, spc+2, flags);
1988 pp_newline (pp);
1989 }
1990 }
1991
1992 newline_and_indent (pp, spc+2);
1993 dump_generic_node (pp, BIND_EXPR_BODY (node), spc+2, flags, true);
1994 newline_and_indent (pp, spc);
1995 pp_right_brace (pp);
1996 }
1997 is_expr = false;
1998 break;
1999
2000 case CALL_EXPR:
2001 if (CALL_EXPR_FN (node) != NULL_TREE)
2002 print_call_name (pp, CALL_EXPR_FN (node), flags);
2003 else
2004 pp_string (pp, internal_fn_name (CALL_EXPR_IFN (node)));
2005
2006 /* Print parameters. */
2007 pp_space (pp);
2008 pp_left_paren (pp);
2009 {
2010 tree arg;
2011 call_expr_arg_iterator iter;
2012 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
2013 {
2014 dump_generic_node (pp, arg, spc, flags, false);
2015 if (more_call_expr_args_p (&iter))
2016 {
2017 pp_comma (pp);
2018 pp_space (pp);
2019 }
2020 }
2021 }
2022 if (CALL_EXPR_VA_ARG_PACK (node))
2023 {
2024 if (call_expr_nargs (node) > 0)
2025 {
2026 pp_comma (pp);
2027 pp_space (pp);
2028 }
2029 pp_string (pp, "__builtin_va_arg_pack ()");
2030 }
2031 pp_right_paren (pp);
2032
2033 op1 = CALL_EXPR_STATIC_CHAIN (node);
2034 if (op1)
2035 {
2036 pp_string (pp, " [static-chain: ");
2037 dump_generic_node (pp, op1, spc, flags, false);
2038 pp_right_bracket (pp);
2039 }
2040
2041 if (CALL_EXPR_RETURN_SLOT_OPT (node))
2042 pp_string (pp, " [return slot optimization]");
2043 if (CALL_EXPR_TAILCALL (node))
2044 pp_string (pp, " [tail call]");
2045 break;
2046
2047 case WITH_CLEANUP_EXPR:
2048 NIY;
2049 break;
2050
2051 case CLEANUP_POINT_EXPR:
2052 pp_string (pp, "<<cleanup_point ");
2053 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2054 pp_string (pp, ">>");
2055 break;
2056
2057 case PLACEHOLDER_EXPR:
2058 pp_string (pp, "<PLACEHOLDER_EXPR ");
2059 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2060 pp_greater (pp);
2061 break;
2062
2063 /* Binary arithmetic and logic expressions. */
2064 case WIDEN_SUM_EXPR:
2065 case WIDEN_MULT_EXPR:
2066 case MULT_EXPR:
2067 case MULT_HIGHPART_EXPR:
2068 case PLUS_EXPR:
2069 case POINTER_PLUS_EXPR:
2070 case MINUS_EXPR:
2071 case TRUNC_DIV_EXPR:
2072 case CEIL_DIV_EXPR:
2073 case FLOOR_DIV_EXPR:
2074 case ROUND_DIV_EXPR:
2075 case TRUNC_MOD_EXPR:
2076 case CEIL_MOD_EXPR:
2077 case FLOOR_MOD_EXPR:
2078 case ROUND_MOD_EXPR:
2079 case RDIV_EXPR:
2080 case EXACT_DIV_EXPR:
2081 case LSHIFT_EXPR:
2082 case RSHIFT_EXPR:
2083 case LROTATE_EXPR:
2084 case RROTATE_EXPR:
2085 case WIDEN_LSHIFT_EXPR:
2086 case BIT_IOR_EXPR:
2087 case BIT_XOR_EXPR:
2088 case BIT_AND_EXPR:
2089 case TRUTH_ANDIF_EXPR:
2090 case TRUTH_ORIF_EXPR:
2091 case TRUTH_AND_EXPR:
2092 case TRUTH_OR_EXPR:
2093 case TRUTH_XOR_EXPR:
2094 case LT_EXPR:
2095 case LE_EXPR:
2096 case GT_EXPR:
2097 case GE_EXPR:
2098 case EQ_EXPR:
2099 case NE_EXPR:
2100 case UNLT_EXPR:
2101 case UNLE_EXPR:
2102 case UNGT_EXPR:
2103 case UNGE_EXPR:
2104 case UNEQ_EXPR:
2105 case LTGT_EXPR:
2106 case ORDERED_EXPR:
2107 case UNORDERED_EXPR:
2108 {
2109 const char *op = op_symbol (node);
2110 op0 = TREE_OPERAND (node, 0);
2111 op1 = TREE_OPERAND (node, 1);
2112
2113 /* When the operands are expressions with less priority,
2114 keep semantics of the tree representation. */
2115 if (op_prio (op0) <= op_prio (node))
2116 {
2117 pp_left_paren (pp);
2118 dump_generic_node (pp, op0, spc, flags, false);
2119 pp_right_paren (pp);
2120 }
2121 else
2122 dump_generic_node (pp, op0, spc, flags, false);
2123
2124 pp_space (pp);
2125 pp_string (pp, op);
2126 pp_space (pp);
2127
2128 /* When the operands are expressions with less priority,
2129 keep semantics of the tree representation. */
2130 if (op_prio (op1) <= op_prio (node))
2131 {
2132 pp_left_paren (pp);
2133 dump_generic_node (pp, op1, spc, flags, false);
2134 pp_right_paren (pp);
2135 }
2136 else
2137 dump_generic_node (pp, op1, spc, flags, false);
2138 }
2139 break;
2140
2141 /* Unary arithmetic and logic expressions. */
2142 case NEGATE_EXPR:
2143 case BIT_NOT_EXPR:
2144 case TRUTH_NOT_EXPR:
2145 case ADDR_EXPR:
2146 case PREDECREMENT_EXPR:
2147 case PREINCREMENT_EXPR:
2148 case INDIRECT_REF:
2149 if (TREE_CODE (node) == ADDR_EXPR
2150 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
2151 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
2152 ; /* Do not output '&' for strings and function pointers. */
2153 else
2154 pp_string (pp, op_symbol (node));
2155
2156 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
2157 {
2158 pp_left_paren (pp);
2159 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2160 pp_right_paren (pp);
2161 }
2162 else
2163 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2164 break;
2165
2166 case POSTDECREMENT_EXPR:
2167 case POSTINCREMENT_EXPR:
2168 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
2169 {
2170 pp_left_paren (pp);
2171 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2172 pp_right_paren (pp);
2173 }
2174 else
2175 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2176 pp_string (pp, op_symbol (node));
2177 break;
2178
2179 case MIN_EXPR:
2180 pp_string (pp, "MIN_EXPR <");
2181 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2182 pp_string (pp, ", ");
2183 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2184 pp_greater (pp);
2185 break;
2186
2187 case MAX_EXPR:
2188 pp_string (pp, "MAX_EXPR <");
2189 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2190 pp_string (pp, ", ");
2191 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2192 pp_greater (pp);
2193 break;
2194
2195 case ABS_EXPR:
2196 pp_string (pp, "ABS_EXPR <");
2197 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2198 pp_greater (pp);
2199 break;
2200
2201 case RANGE_EXPR:
2202 NIY;
2203 break;
2204
2205 case ADDR_SPACE_CONVERT_EXPR:
2206 case FIXED_CONVERT_EXPR:
2207 case FIX_TRUNC_EXPR:
2208 case FLOAT_EXPR:
2209 CASE_CONVERT:
2210 type = TREE_TYPE (node);
2211 op0 = TREE_OPERAND (node, 0);
2212 if (type != TREE_TYPE (op0))
2213 {
2214 pp_left_paren (pp);
2215 dump_generic_node (pp, type, spc, flags, false);
2216 pp_string (pp, ") ");
2217 }
2218 if (op_prio (op0) < op_prio (node))
2219 pp_left_paren (pp);
2220 dump_generic_node (pp, op0, spc, flags, false);
2221 if (op_prio (op0) < op_prio (node))
2222 pp_right_paren (pp);
2223 break;
2224
2225 case VIEW_CONVERT_EXPR:
2226 pp_string (pp, "VIEW_CONVERT_EXPR<");
2227 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2228 pp_string (pp, ">(");
2229 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2230 pp_right_paren (pp);
2231 break;
2232
2233 case PAREN_EXPR:
2234 pp_string (pp, "((");
2235 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2236 pp_string (pp, "))");
2237 break;
2238
2239 case NON_LVALUE_EXPR:
2240 pp_string (pp, "NON_LVALUE_EXPR <");
2241 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2242 pp_greater (pp);
2243 break;
2244
2245 case SAVE_EXPR:
2246 pp_string (pp, "SAVE_EXPR <");
2247 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2248 pp_greater (pp);
2249 break;
2250
2251 case COMPLEX_EXPR:
2252 pp_string (pp, "COMPLEX_EXPR <");
2253 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2254 pp_string (pp, ", ");
2255 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2256 pp_greater (pp);
2257 break;
2258
2259 case CONJ_EXPR:
2260 pp_string (pp, "CONJ_EXPR <");
2261 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2262 pp_greater (pp);
2263 break;
2264
2265 case REALPART_EXPR:
2266 pp_string (pp, "REALPART_EXPR <");
2267 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2268 pp_greater (pp);
2269 break;
2270
2271 case IMAGPART_EXPR:
2272 pp_string (pp, "IMAGPART_EXPR <");
2273 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2274 pp_greater (pp);
2275 break;
2276
2277 case VA_ARG_EXPR:
2278 pp_string (pp, "VA_ARG_EXPR <");
2279 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2280 pp_greater (pp);
2281 break;
2282
2283 case TRY_FINALLY_EXPR:
2284 case TRY_CATCH_EXPR:
2285 pp_string (pp, "try");
2286 newline_and_indent (pp, spc+2);
2287 pp_left_brace (pp);
2288 newline_and_indent (pp, spc+4);
2289 dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, flags, true);
2290 newline_and_indent (pp, spc+2);
2291 pp_right_brace (pp);
2292 newline_and_indent (pp, spc);
2293 pp_string (pp,
2294 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
2295 newline_and_indent (pp, spc+2);
2296 pp_left_brace (pp);
2297 newline_and_indent (pp, spc+4);
2298 dump_generic_node (pp, TREE_OPERAND (node, 1), spc+4, flags, true);
2299 newline_and_indent (pp, spc+2);
2300 pp_right_brace (pp);
2301 is_expr = false;
2302 break;
2303
2304 case CATCH_EXPR:
2305 pp_string (pp, "catch (");
2306 dump_generic_node (pp, CATCH_TYPES (node), spc+2, flags, false);
2307 pp_right_paren (pp);
2308 newline_and_indent (pp, spc+2);
2309 pp_left_brace (pp);
2310 newline_and_indent (pp, spc+4);
2311 dump_generic_node (pp, CATCH_BODY (node), spc+4, flags, true);
2312 newline_and_indent (pp, spc+2);
2313 pp_right_brace (pp);
2314 is_expr = false;
2315 break;
2316
2317 case EH_FILTER_EXPR:
2318 pp_string (pp, "<<<eh_filter (");
2319 dump_generic_node (pp, EH_FILTER_TYPES (node), spc+2, flags, false);
2320 pp_string (pp, ")>>>");
2321 newline_and_indent (pp, spc+2);
2322 pp_left_brace (pp);
2323 newline_and_indent (pp, spc+4);
2324 dump_generic_node (pp, EH_FILTER_FAILURE (node), spc+4, flags, true);
2325 newline_and_indent (pp, spc+2);
2326 pp_right_brace (pp);
2327 is_expr = false;
2328 break;
2329
2330 case LABEL_EXPR:
2331 op0 = TREE_OPERAND (node, 0);
2332 /* If this is for break or continue, don't bother printing it. */
2333 if (DECL_NAME (op0))
2334 {
2335 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
2336 if (strcmp (name, "break") == 0
2337 || strcmp (name, "continue") == 0)
2338 break;
2339 }
2340 dump_generic_node (pp, op0, spc, flags, false);
2341 pp_colon (pp);
2342 if (DECL_NONLOCAL (op0))
2343 pp_string (pp, " [non-local]");
2344 break;
2345
2346 case LOOP_EXPR:
2347 pp_string (pp, "while (1)");
2348 if (!(flags & TDF_SLIM))
2349 {
2350 newline_and_indent (pp, spc+2);
2351 pp_left_brace (pp);
2352 newline_and_indent (pp, spc+4);
2353 dump_generic_node (pp, LOOP_EXPR_BODY (node), spc+4, flags, true);
2354 newline_and_indent (pp, spc+2);
2355 pp_right_brace (pp);
2356 }
2357 is_expr = false;
2358 break;
2359
2360 case PREDICT_EXPR:
2361 pp_string (pp, "// predicted ");
2362 if (PREDICT_EXPR_OUTCOME (node))
2363 pp_string (pp, "likely by ");
2364 else
2365 pp_string (pp, "unlikely by ");
2366 pp_string (pp, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
2367 pp_string (pp, " predictor.");
2368 break;
2369
2370 case ANNOTATE_EXPR:
2371 pp_string (pp, "ANNOTATE_EXPR <");
2372 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2373 switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1)))
2374 {
2375 case annot_expr_ivdep_kind:
2376 pp_string (pp, ", ivdep");
2377 break;
2378 case annot_expr_no_vector_kind:
2379 pp_string (pp, ", no-vector");
2380 break;
2381 case annot_expr_vector_kind:
2382 pp_string (pp, ", vector");
2383 break;
2384 default:
2385 gcc_unreachable ();
2386 }
2387 pp_greater (pp);
2388 break;
2389
2390 case RETURN_EXPR:
2391 pp_string (pp, "return");
2392 op0 = TREE_OPERAND (node, 0);
2393 if (op0)
2394 {
2395 pp_space (pp);
2396 if (TREE_CODE (op0) == MODIFY_EXPR)
2397 dump_generic_node (pp, TREE_OPERAND (op0, 1),
2398 spc, flags, false);
2399 else
2400 dump_generic_node (pp, op0, spc, flags, false);
2401 }
2402 break;
2403
2404 case EXIT_EXPR:
2405 pp_string (pp, "if (");
2406 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2407 pp_string (pp, ") break");
2408 break;
2409
2410 case SWITCH_EXPR:
2411 pp_string (pp, "switch (");
2412 dump_generic_node (pp, SWITCH_COND (node), spc, flags, false);
2413 pp_right_paren (pp);
2414 if (!(flags & TDF_SLIM))
2415 {
2416 newline_and_indent (pp, spc+2);
2417 pp_left_brace (pp);
2418 if (SWITCH_BODY (node))
2419 {
2420 newline_and_indent (pp, spc+4);
2421 dump_generic_node (pp, SWITCH_BODY (node), spc+4, flags,
2422 true);
2423 }
2424 else
2425 {
2426 tree vec = SWITCH_LABELS (node);
2427 size_t i, n = TREE_VEC_LENGTH (vec);
2428 for (i = 0; i < n; ++i)
2429 {
2430 tree elt = TREE_VEC_ELT (vec, i);
2431 newline_and_indent (pp, spc+4);
2432 if (elt)
2433 {
2434 dump_generic_node (pp, elt, spc+4, flags, false);
2435 pp_string (pp, " goto ");
2436 dump_generic_node (pp, CASE_LABEL (elt), spc+4,
2437 flags, true);
2438 pp_semicolon (pp);
2439 }
2440 else
2441 pp_string (pp, "case ???: goto ???;");
2442 }
2443 }
2444 newline_and_indent (pp, spc+2);
2445 pp_right_brace (pp);
2446 }
2447 is_expr = false;
2448 break;
2449
2450 case GOTO_EXPR:
2451 op0 = GOTO_DESTINATION (node);
2452 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
2453 {
2454 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
2455 if (strcmp (name, "break") == 0
2456 || strcmp (name, "continue") == 0)
2457 {
2458 pp_string (pp, name);
2459 break;
2460 }
2461 }
2462 pp_string (pp, "goto ");
2463 dump_generic_node (pp, op0, spc, flags, false);
2464 break;
2465
2466 case ASM_EXPR:
2467 pp_string (pp, "__asm__");
2468 if (ASM_VOLATILE_P (node))
2469 pp_string (pp, " __volatile__");
2470 pp_left_paren (pp);
2471 dump_generic_node (pp, ASM_STRING (node), spc, flags, false);
2472 pp_colon (pp);
2473 dump_generic_node (pp, ASM_OUTPUTS (node), spc, flags, false);
2474 pp_colon (pp);
2475 dump_generic_node (pp, ASM_INPUTS (node), spc, flags, false);
2476 if (ASM_CLOBBERS (node))
2477 {
2478 pp_colon (pp);
2479 dump_generic_node (pp, ASM_CLOBBERS (node), spc, flags, false);
2480 }
2481 pp_right_paren (pp);
2482 break;
2483
2484 case CASE_LABEL_EXPR:
2485 if (CASE_LOW (node) && CASE_HIGH (node))
2486 {
2487 pp_string (pp, "case ");
2488 dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
2489 pp_string (pp, " ... ");
2490 dump_generic_node (pp, CASE_HIGH (node), spc, flags, false);
2491 }
2492 else if (CASE_LOW (node))
2493 {
2494 pp_string (pp, "case ");
2495 dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
2496 }
2497 else
2498 pp_string (pp, "default");
2499 pp_colon (pp);
2500 break;
2501
2502 case OBJ_TYPE_REF:
2503 pp_string (pp, "OBJ_TYPE_REF(");
2504 dump_generic_node (pp, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
2505 pp_semicolon (pp);
2506 if (!(flags & TDF_SLIM) && virtual_method_call_p (node))
2507 {
2508 pp_string (pp, "(");
2509 dump_generic_node (pp, obj_type_ref_class (node), spc, flags, false);
2510 pp_string (pp, ")");
2511 }
2512 dump_generic_node (pp, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
2513 pp_arrow (pp);
2514 dump_generic_node (pp, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
2515 pp_right_paren (pp);
2516 break;
2517
2518 case SSA_NAME:
2519 if (SSA_NAME_IDENTIFIER (node))
2520 dump_generic_node (pp, SSA_NAME_IDENTIFIER (node),
2521 spc, flags, false);
2522 pp_underscore (pp);
2523 pp_decimal_int (pp, SSA_NAME_VERSION (node));
2524 if (SSA_NAME_IS_DEFAULT_DEF (node))
2525 pp_string (pp, "(D)");
2526 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
2527 pp_string (pp, "(ab)");
2528 break;
2529
2530 case WITH_SIZE_EXPR:
2531 pp_string (pp, "WITH_SIZE_EXPR <");
2532 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2533 pp_string (pp, ", ");
2534 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2535 pp_greater (pp);
2536 break;
2537
2538 case ASSERT_EXPR:
2539 pp_string (pp, "ASSERT_EXPR <");
2540 dump_generic_node (pp, ASSERT_EXPR_VAR (node), spc, flags, false);
2541 pp_string (pp, ", ");
2542 dump_generic_node (pp, ASSERT_EXPR_COND (node), spc, flags, false);
2543 pp_greater (pp);
2544 break;
2545
2546 case SCEV_KNOWN:
2547 pp_string (pp, "scev_known");
2548 break;
2549
2550 case SCEV_NOT_KNOWN:
2551 pp_string (pp, "scev_not_known");
2552 break;
2553
2554 case POLYNOMIAL_CHREC:
2555 pp_left_brace (pp);
2556 dump_generic_node (pp, CHREC_LEFT (node), spc, flags, false);
2557 pp_string (pp, ", +, ");
2558 dump_generic_node (pp, CHREC_RIGHT (node), spc, flags, false);
2559 pp_string (pp, "}_");
2560 dump_generic_node (pp, CHREC_VAR (node), spc, flags, false);
2561 is_stmt = false;
2562 break;
2563
2564 case REALIGN_LOAD_EXPR:
2565 pp_string (pp, "REALIGN_LOAD <");
2566 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2567 pp_string (pp, ", ");
2568 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2569 pp_string (pp, ", ");
2570 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2571 pp_greater (pp);
2572 break;
2573
2574 case VEC_COND_EXPR:
2575 pp_string (pp, " VEC_COND_EXPR < ");
2576 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2577 pp_string (pp, " , ");
2578 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2579 pp_string (pp, " , ");
2580 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2581 pp_string (pp, " > ");
2582 break;
2583
2584 case VEC_PERM_EXPR:
2585 pp_string (pp, " VEC_PERM_EXPR < ");
2586 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2587 pp_string (pp, " , ");
2588 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2589 pp_string (pp, " , ");
2590 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2591 pp_string (pp, " > ");
2592 break;
2593
2594 case DOT_PROD_EXPR:
2595 pp_string (pp, " DOT_PROD_EXPR < ");
2596 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2597 pp_string (pp, ", ");
2598 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2599 pp_string (pp, ", ");
2600 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2601 pp_string (pp, " > ");
2602 break;
2603
2604 case WIDEN_MULT_PLUS_EXPR:
2605 pp_string (pp, " WIDEN_MULT_PLUS_EXPR < ");
2606 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2607 pp_string (pp, ", ");
2608 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2609 pp_string (pp, ", ");
2610 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2611 pp_string (pp, " > ");
2612 break;
2613
2614 case WIDEN_MULT_MINUS_EXPR:
2615 pp_string (pp, " WIDEN_MULT_MINUS_EXPR < ");
2616 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2617 pp_string (pp, ", ");
2618 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2619 pp_string (pp, ", ");
2620 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2621 pp_string (pp, " > ");
2622 break;
2623
2624 case FMA_EXPR:
2625 pp_string (pp, " FMA_EXPR < ");
2626 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2627 pp_string (pp, ", ");
2628 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2629 pp_string (pp, ", ");
2630 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2631 pp_string (pp, " > ");
2632 break;
2633
2634 case OACC_PARALLEL:
2635 pp_string (pp, "#pragma acc parallel");
2636 dump_omp_clauses (pp, OACC_PARALLEL_CLAUSES (node), spc, flags);
2637 goto dump_omp_body;
2638
2639 case OACC_KERNELS:
2640 pp_string (pp, "#pragma acc kernels");
2641 dump_omp_clauses (pp, OACC_KERNELS_CLAUSES (node), spc, flags);
2642 goto dump_omp_body;
2643
2644 case OACC_DATA:
2645 pp_string (pp, "#pragma acc data");
2646 dump_omp_clauses (pp, OACC_DATA_CLAUSES (node), spc, flags);
2647 goto dump_omp_body;
2648
2649 case OACC_HOST_DATA:
2650 pp_string (pp, "#pragma acc host_data");
2651 dump_omp_clauses (pp, OACC_HOST_DATA_CLAUSES (node), spc, flags);
2652 goto dump_omp_body;
2653
2654 case OACC_DECLARE:
2655 pp_string (pp, "#pragma acc declare");
2656 dump_omp_clauses (pp, OACC_DECLARE_CLAUSES (node), spc, flags);
2657 break;
2658
2659 case OACC_UPDATE:
2660 pp_string (pp, "#pragma acc update");
2661 dump_omp_clauses (pp, OACC_UPDATE_CLAUSES (node), spc, flags);
2662 break;
2663
2664 case OACC_ENTER_DATA:
2665 pp_string (pp, "#pragma acc enter data");
2666 dump_omp_clauses (pp, OACC_ENTER_DATA_CLAUSES (node), spc, flags);
2667 break;
2668
2669 case OACC_EXIT_DATA:
2670 pp_string (pp, "#pragma acc exit data");
2671 dump_omp_clauses (pp, OACC_EXIT_DATA_CLAUSES (node), spc, flags);
2672 break;
2673
2674 case OACC_CACHE:
2675 pp_string (pp, "#pragma acc cache");
2676 dump_omp_clauses (pp, OACC_CACHE_CLAUSES (node), spc, flags);
2677 break;
2678
2679 case OMP_PARALLEL:
2680 pp_string (pp, "#pragma omp parallel");
2681 dump_omp_clauses (pp, OMP_PARALLEL_CLAUSES (node), spc, flags);
2682
2683 dump_omp_body:
2684 if (!(flags & TDF_SLIM) && OMP_BODY (node))
2685 {
2686 newline_and_indent (pp, spc + 2);
2687 pp_left_brace (pp);
2688 newline_and_indent (pp, spc + 4);
2689 dump_generic_node (pp, OMP_BODY (node), spc + 4, flags, false);
2690 newline_and_indent (pp, spc + 2);
2691 pp_right_brace (pp);
2692 }
2693 is_expr = false;
2694 break;
2695
2696 case OMP_TASK:
2697 pp_string (pp, "#pragma omp task");
2698 dump_omp_clauses (pp, OMP_TASK_CLAUSES (node), spc, flags);
2699 goto dump_omp_body;
2700
2701 case OMP_FOR:
2702 pp_string (pp, "#pragma omp for");
2703 goto dump_omp_loop;
2704
2705 case OMP_SIMD:
2706 pp_string (pp, "#pragma omp simd");
2707 goto dump_omp_loop;
2708
2709 case CILK_SIMD:
2710 pp_string (pp, "#pragma simd");
2711 goto dump_omp_loop;
2712
2713 case CILK_FOR:
2714 /* This label points one line after dumping the clauses.
2715 For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2716 parameters are printed out. */
2717 goto dump_omp_loop_cilk_for;
2718
2719 case OMP_DISTRIBUTE:
2720 pp_string (pp, "#pragma omp distribute");
2721 goto dump_omp_loop;
2722
2723 case OMP_TASKLOOP:
2724 pp_string (pp, "#pragma omp taskloop");
2725 goto dump_omp_loop;
2726
2727 case OACC_LOOP:
2728 pp_string (pp, "#pragma acc loop");
2729 goto dump_omp_loop;
2730
2731 case OMP_TEAMS:
2732 pp_string (pp, "#pragma omp teams");
2733 dump_omp_clauses (pp, OMP_TEAMS_CLAUSES (node), spc, flags);
2734 goto dump_omp_body;
2735
2736 case OMP_TARGET_DATA:
2737 pp_string (pp, "#pragma omp target data");
2738 dump_omp_clauses (pp, OMP_TARGET_DATA_CLAUSES (node), spc, flags);
2739 goto dump_omp_body;
2740
2741 case OMP_TARGET_ENTER_DATA:
2742 pp_string (pp, "#pragma omp target enter data");
2743 dump_omp_clauses (pp, OMP_TARGET_ENTER_DATA_CLAUSES (node), spc, flags);
2744 is_expr = false;
2745 break;
2746
2747 case OMP_TARGET_EXIT_DATA:
2748 pp_string (pp, "#pragma omp target exit data");
2749 dump_omp_clauses (pp, OMP_TARGET_EXIT_DATA_CLAUSES (node), spc, flags);
2750 is_expr = false;
2751 break;
2752
2753 case OMP_TARGET:
2754 pp_string (pp, "#pragma omp target");
2755 dump_omp_clauses (pp, OMP_TARGET_CLAUSES (node), spc, flags);
2756 goto dump_omp_body;
2757
2758 case OMP_TARGET_UPDATE:
2759 pp_string (pp, "#pragma omp target update");
2760 dump_omp_clauses (pp, OMP_TARGET_UPDATE_CLAUSES (node), spc, flags);
2761 is_expr = false;
2762 break;
2763
2764 dump_omp_loop:
2765 dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
2766
2767 dump_omp_loop_cilk_for:
2768 if (!(flags & TDF_SLIM))
2769 {
2770 int i;
2771
2772 if (OMP_FOR_PRE_BODY (node))
2773 {
2774 if (TREE_CODE (node) == CILK_FOR)
2775 pp_string (pp, " ");
2776 else
2777 newline_and_indent (pp, spc + 2);
2778 pp_left_brace (pp);
2779 spc += 4;
2780 newline_and_indent (pp, spc);
2781 dump_generic_node (pp, OMP_FOR_PRE_BODY (node),
2782 spc, flags, false);
2783 }
2784 if (OMP_FOR_INIT (node))
2785 {
2786 spc -= 2;
2787 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
2788 {
2789 spc += 2;
2790 if (TREE_CODE (node) != CILK_FOR || OMP_FOR_PRE_BODY (node))
2791 newline_and_indent (pp, spc);
2792 if (TREE_CODE (node) == CILK_FOR)
2793 pp_string (pp, "_Cilk_for (");
2794 else
2795 pp_string (pp, "for (");
2796 dump_generic_node (pp,
2797 TREE_VEC_ELT (OMP_FOR_INIT (node), i),
2798 spc, flags, false);
2799 pp_string (pp, "; ");
2800 dump_generic_node (pp,
2801 TREE_VEC_ELT (OMP_FOR_COND (node), i),
2802 spc, flags, false);
2803 pp_string (pp, "; ");
2804 dump_generic_node (pp,
2805 TREE_VEC_ELT (OMP_FOR_INCR (node), i),
2806 spc, flags, false);
2807 pp_right_paren (pp);
2808 }
2809 if (TREE_CODE (node) == CILK_FOR)
2810 dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
2811 }
2812 if (OMP_FOR_BODY (node))
2813 {
2814 newline_and_indent (pp, spc + 2);
2815 pp_left_brace (pp);
2816 newline_and_indent (pp, spc + 4);
2817 dump_generic_node (pp, OMP_FOR_BODY (node), spc + 4, flags,
2818 false);
2819 newline_and_indent (pp, spc + 2);
2820 pp_right_brace (pp);
2821 }
2822 if (OMP_FOR_INIT (node))
2823 spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
2824 if (OMP_FOR_PRE_BODY (node))
2825 {
2826 spc -= 4;
2827 newline_and_indent (pp, spc + 2);
2828 pp_right_brace (pp);
2829 }
2830 }
2831 is_expr = false;
2832 break;
2833
2834 case OMP_SECTIONS:
2835 pp_string (pp, "#pragma omp sections");
2836 dump_omp_clauses (pp, OMP_SECTIONS_CLAUSES (node), spc, flags);
2837 goto dump_omp_body;
2838
2839 case OMP_SECTION:
2840 pp_string (pp, "#pragma omp section");
2841 goto dump_omp_body;
2842
2843 case OMP_MASTER:
2844 pp_string (pp, "#pragma omp master");
2845 goto dump_omp_body;
2846
2847 case OMP_TASKGROUP:
2848 pp_string (pp, "#pragma omp taskgroup");
2849 goto dump_omp_body;
2850
2851 case OMP_ORDERED:
2852 pp_string (pp, "#pragma omp ordered");
2853 dump_omp_clauses (pp, OMP_ORDERED_CLAUSES (node), spc, flags);
2854 goto dump_omp_body;
2855
2856 case OMP_CRITICAL:
2857 pp_string (pp, "#pragma omp critical");
2858 if (OMP_CRITICAL_NAME (node))
2859 {
2860 pp_space (pp);
2861 pp_left_paren (pp);
2862 dump_generic_node (pp, OMP_CRITICAL_NAME (node), spc,
2863 flags, false);
2864 pp_right_paren (pp);
2865 }
2866 dump_omp_clauses (pp, OMP_CRITICAL_CLAUSES (node), spc, flags);
2867 goto dump_omp_body;
2868
2869 case OMP_ATOMIC:
2870 pp_string (pp, "#pragma omp atomic");
2871 if (OMP_ATOMIC_SEQ_CST (node))
2872 pp_string (pp, " seq_cst");
2873 newline_and_indent (pp, spc + 2);
2874 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2875 pp_space (pp);
2876 pp_equal (pp);
2877 pp_space (pp);
2878 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2879 break;
2880
2881 case OMP_ATOMIC_READ:
2882 pp_string (pp, "#pragma omp atomic read");
2883 if (OMP_ATOMIC_SEQ_CST (node))
2884 pp_string (pp, " seq_cst");
2885 newline_and_indent (pp, spc + 2);
2886 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2887 pp_space (pp);
2888 break;
2889
2890 case OMP_ATOMIC_CAPTURE_OLD:
2891 case OMP_ATOMIC_CAPTURE_NEW:
2892 pp_string (pp, "#pragma omp atomic capture");
2893 if (OMP_ATOMIC_SEQ_CST (node))
2894 pp_string (pp, " seq_cst");
2895 newline_and_indent (pp, spc + 2);
2896 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2897 pp_space (pp);
2898 pp_equal (pp);
2899 pp_space (pp);
2900 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2901 break;
2902
2903 case OMP_SINGLE:
2904 pp_string (pp, "#pragma omp single");
2905 dump_omp_clauses (pp, OMP_SINGLE_CLAUSES (node), spc, flags);
2906 goto dump_omp_body;
2907
2908 case OMP_CLAUSE:
2909 dump_omp_clause (pp, node, spc, flags);
2910 is_expr = false;
2911 break;
2912
2913 case TRANSACTION_EXPR:
2914 if (TRANSACTION_EXPR_OUTER (node))
2915 pp_string (pp, "__transaction_atomic [[outer]]");
2916 else if (TRANSACTION_EXPR_RELAXED (node))
2917 pp_string (pp, "__transaction_relaxed");
2918 else
2919 pp_string (pp, "__transaction_atomic");
2920 if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
2921 {
2922 newline_and_indent (pp, spc);
2923 pp_left_brace (pp);
2924 newline_and_indent (pp, spc + 2);
2925 dump_generic_node (pp, TRANSACTION_EXPR_BODY (node),
2926 spc + 2, flags, false);
2927 newline_and_indent (pp, spc);
2928 pp_right_brace (pp);
2929 }
2930 is_expr = false;
2931 break;
2932
2933 case REDUC_MAX_EXPR:
2934 pp_string (pp, " REDUC_MAX_EXPR < ");
2935 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2936 pp_string (pp, " > ");
2937 break;
2938
2939 case REDUC_MIN_EXPR:
2940 pp_string (pp, " REDUC_MIN_EXPR < ");
2941 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2942 pp_string (pp, " > ");
2943 break;
2944
2945 case REDUC_PLUS_EXPR:
2946 pp_string (pp, " REDUC_PLUS_EXPR < ");
2947 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2948 pp_string (pp, " > ");
2949 break;
2950
2951 case VEC_WIDEN_MULT_HI_EXPR:
2952 case VEC_WIDEN_MULT_LO_EXPR:
2953 case VEC_WIDEN_MULT_EVEN_EXPR:
2954 case VEC_WIDEN_MULT_ODD_EXPR:
2955 case VEC_WIDEN_LSHIFT_HI_EXPR:
2956 case VEC_WIDEN_LSHIFT_LO_EXPR:
2957 pp_space (pp);
2958 for (str = get_tree_code_name (code); *str; str++)
2959 pp_character (pp, TOUPPER (*str));
2960 pp_string (pp, " < ");
2961 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2962 pp_string (pp, ", ");
2963 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2964 pp_string (pp, " > ");
2965 break;
2966
2967 case VEC_UNPACK_HI_EXPR:
2968 pp_string (pp, " VEC_UNPACK_HI_EXPR < ");
2969 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2970 pp_string (pp, " > ");
2971 break;
2972
2973 case VEC_UNPACK_LO_EXPR:
2974 pp_string (pp, " VEC_UNPACK_LO_EXPR < ");
2975 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2976 pp_string (pp, " > ");
2977 break;
2978
2979 case VEC_UNPACK_FLOAT_HI_EXPR:
2980 pp_string (pp, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2981 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2982 pp_string (pp, " > ");
2983 break;
2984
2985 case VEC_UNPACK_FLOAT_LO_EXPR:
2986 pp_string (pp, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2987 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2988 pp_string (pp, " > ");
2989 break;
2990
2991 case VEC_PACK_TRUNC_EXPR:
2992 pp_string (pp, " VEC_PACK_TRUNC_EXPR < ");
2993 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2994 pp_string (pp, ", ");
2995 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2996 pp_string (pp, " > ");
2997 break;
2998
2999 case VEC_PACK_SAT_EXPR:
3000 pp_string (pp, " VEC_PACK_SAT_EXPR < ");
3001 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3002 pp_string (pp, ", ");
3003 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3004 pp_string (pp, " > ");
3005 break;
3006
3007 case VEC_PACK_FIX_TRUNC_EXPR:
3008 pp_string (pp, " VEC_PACK_FIX_TRUNC_EXPR < ");
3009 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3010 pp_string (pp, ", ");
3011 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3012 pp_string (pp, " > ");
3013 break;
3014
3015 case BLOCK:
3016 dump_block_node (pp, node, spc, flags);
3017 break;
3018
3019 case CILK_SPAWN_STMT:
3020 pp_string (pp, "_Cilk_spawn ");
3021 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3022 break;
3023
3024 case CILK_SYNC_STMT:
3025 pp_string (pp, "_Cilk_sync");
3026 break;
3027
3028 default:
3029 NIY;
3030 }
3031
3032 if (is_stmt && is_expr)
3033 pp_semicolon (pp);
3034
3035 return spc;
3036 }
3037
3038 /* Print the declaration of a variable. */
3039
3040 void
3041 print_declaration (pretty_printer *pp, tree t, int spc, int flags)
3042 {
3043 INDENT (spc);
3044
3045 if (TREE_CODE(t) == NAMELIST_DECL)
3046 {
3047 pp_string(pp, "namelist ");
3048 dump_decl_name (pp, t, flags);
3049 pp_semicolon (pp);
3050 return;
3051 }
3052
3053 if (TREE_CODE (t) == TYPE_DECL)
3054 pp_string (pp, "typedef ");
3055
3056 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
3057 pp_string (pp, "register ");
3058
3059 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
3060 pp_string (pp, "extern ");
3061 else if (TREE_STATIC (t))
3062 pp_string (pp, "static ");
3063
3064 /* Print the type and name. */
3065 if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
3066 {
3067 tree tmp;
3068
3069 /* Print array's type. */
3070 tmp = TREE_TYPE (t);
3071 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
3072 tmp = TREE_TYPE (tmp);
3073 dump_generic_node (pp, TREE_TYPE (tmp), spc, flags, false);
3074
3075 /* Print variable's name. */
3076 pp_space (pp);
3077 dump_generic_node (pp, t, spc, flags, false);
3078
3079 /* Print the dimensions. */
3080 tmp = TREE_TYPE (t);
3081 while (TREE_CODE (tmp) == ARRAY_TYPE)
3082 {
3083 dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
3084 tmp = TREE_TYPE (tmp);
3085 }
3086 }
3087 else if (TREE_CODE (t) == FUNCTION_DECL)
3088 {
3089 dump_generic_node (pp, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
3090 pp_space (pp);
3091 dump_decl_name (pp, t, flags);
3092 dump_function_declaration (pp, TREE_TYPE (t), spc, flags);
3093 }
3094 else
3095 {
3096 /* Print type declaration. */
3097 dump_generic_node (pp, TREE_TYPE (t), spc, flags, false);
3098
3099 /* Print variable's name. */
3100 pp_space (pp);
3101 dump_generic_node (pp, t, spc, flags, false);
3102 }
3103
3104 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
3105 {
3106 pp_string (pp, " __asm__ ");
3107 pp_left_paren (pp);
3108 dump_generic_node (pp, DECL_ASSEMBLER_NAME (t), spc, flags, false);
3109 pp_right_paren (pp);
3110 }
3111
3112 /* The initial value of a function serves to determine whether the function
3113 is declared or defined. So the following does not apply to function
3114 nodes. */
3115 if (TREE_CODE (t) != FUNCTION_DECL)
3116 {
3117 /* Print the initial value. */
3118 if (DECL_INITIAL (t))
3119 {
3120 pp_space (pp);
3121 pp_equal (pp);
3122 pp_space (pp);
3123 dump_generic_node (pp, DECL_INITIAL (t), spc, flags, false);
3124 }
3125 }
3126
3127 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
3128 {
3129 pp_string (pp, " [value-expr: ");
3130 dump_generic_node (pp, DECL_VALUE_EXPR (t), spc, flags, false);
3131 pp_right_bracket (pp);
3132 }
3133
3134 pp_semicolon (pp);
3135 }
3136
3137
3138 /* Prints a structure: name, fields, and methods.
3139 FIXME: Still incomplete. */
3140
3141 static void
3142 print_struct_decl (pretty_printer *pp, const_tree node, int spc, int flags)
3143 {
3144 /* Print the name of the structure. */
3145 if (TYPE_NAME (node))
3146 {
3147 INDENT (spc);
3148 if (TREE_CODE (node) == RECORD_TYPE)
3149 pp_string (pp, "struct ");
3150 else if ((TREE_CODE (node) == UNION_TYPE
3151 || TREE_CODE (node) == QUAL_UNION_TYPE))
3152 pp_string (pp, "union ");
3153
3154 dump_generic_node (pp, TYPE_NAME (node), spc, 0, false);
3155 }
3156
3157 /* Print the contents of the structure. */
3158 pp_newline (pp);
3159 INDENT (spc);
3160 pp_left_brace (pp);
3161 pp_newline (pp);
3162
3163 /* Print the fields of the structure. */
3164 {
3165 tree tmp;
3166 tmp = TYPE_FIELDS (node);
3167 while (tmp)
3168 {
3169 /* Avoid to print recursively the structure. */
3170 /* FIXME : Not implemented correctly...,
3171 what about the case when we have a cycle in the contain graph? ...
3172 Maybe this could be solved by looking at the scope in which the
3173 structure was declared. */
3174 if (TREE_TYPE (tmp) != node
3175 && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
3176 || TREE_TYPE (TREE_TYPE (tmp)) != node))
3177 {
3178 print_declaration (pp, tmp, spc+2, flags);
3179 pp_newline (pp);
3180 }
3181 tmp = DECL_CHAIN (tmp);
3182 }
3183 }
3184 INDENT (spc);
3185 pp_right_brace (pp);
3186 }
3187
3188 /* Return the priority of the operator CODE.
3189
3190 From lowest to highest precedence with either left-to-right (L-R)
3191 or right-to-left (R-L) associativity]:
3192
3193 1 [L-R] ,
3194 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3195 3 [R-L] ?:
3196 4 [L-R] ||
3197 5 [L-R] &&
3198 6 [L-R] |
3199 7 [L-R] ^
3200 8 [L-R] &
3201 9 [L-R] == !=
3202 10 [L-R] < <= > >=
3203 11 [L-R] << >>
3204 12 [L-R] + -
3205 13 [L-R] * / %
3206 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3207 15 [L-R] fn() [] -> .
3208
3209 unary +, - and * have higher precedence than the corresponding binary
3210 operators. */
3211
3212 int
3213 op_code_prio (enum tree_code code)
3214 {
3215 switch (code)
3216 {
3217 case TREE_LIST:
3218 case COMPOUND_EXPR:
3219 case BIND_EXPR:
3220 return 1;
3221
3222 case MODIFY_EXPR:
3223 case INIT_EXPR:
3224 return 2;
3225
3226 case COND_EXPR:
3227 return 3;
3228
3229 case TRUTH_OR_EXPR:
3230 case TRUTH_ORIF_EXPR:
3231 return 4;
3232
3233 case TRUTH_AND_EXPR:
3234 case TRUTH_ANDIF_EXPR:
3235 return 5;
3236
3237 case BIT_IOR_EXPR:
3238 return 6;
3239
3240 case BIT_XOR_EXPR:
3241 case TRUTH_XOR_EXPR:
3242 return 7;
3243
3244 case BIT_AND_EXPR:
3245 return 8;
3246
3247 case EQ_EXPR:
3248 case NE_EXPR:
3249 return 9;
3250
3251 case UNLT_EXPR:
3252 case UNLE_EXPR:
3253 case UNGT_EXPR:
3254 case UNGE_EXPR:
3255 case UNEQ_EXPR:
3256 case LTGT_EXPR:
3257 case ORDERED_EXPR:
3258 case UNORDERED_EXPR:
3259 case LT_EXPR:
3260 case LE_EXPR:
3261 case GT_EXPR:
3262 case GE_EXPR:
3263 return 10;
3264
3265 case LSHIFT_EXPR:
3266 case RSHIFT_EXPR:
3267 case LROTATE_EXPR:
3268 case RROTATE_EXPR:
3269 case VEC_WIDEN_LSHIFT_HI_EXPR:
3270 case VEC_WIDEN_LSHIFT_LO_EXPR:
3271 case WIDEN_LSHIFT_EXPR:
3272 return 11;
3273
3274 case WIDEN_SUM_EXPR:
3275 case PLUS_EXPR:
3276 case POINTER_PLUS_EXPR:
3277 case MINUS_EXPR:
3278 return 12;
3279
3280 case VEC_WIDEN_MULT_HI_EXPR:
3281 case VEC_WIDEN_MULT_LO_EXPR:
3282 case WIDEN_MULT_EXPR:
3283 case DOT_PROD_EXPR:
3284 case WIDEN_MULT_PLUS_EXPR:
3285 case WIDEN_MULT_MINUS_EXPR:
3286 case MULT_EXPR:
3287 case MULT_HIGHPART_EXPR:
3288 case TRUNC_DIV_EXPR:
3289 case CEIL_DIV_EXPR:
3290 case FLOOR_DIV_EXPR:
3291 case ROUND_DIV_EXPR:
3292 case RDIV_EXPR:
3293 case EXACT_DIV_EXPR:
3294 case TRUNC_MOD_EXPR:
3295 case CEIL_MOD_EXPR:
3296 case FLOOR_MOD_EXPR:
3297 case ROUND_MOD_EXPR:
3298 case FMA_EXPR:
3299 return 13;
3300
3301 case TRUTH_NOT_EXPR:
3302 case BIT_NOT_EXPR:
3303 case POSTINCREMENT_EXPR:
3304 case POSTDECREMENT_EXPR:
3305 case PREINCREMENT_EXPR:
3306 case PREDECREMENT_EXPR:
3307 case NEGATE_EXPR:
3308 case INDIRECT_REF:
3309 case ADDR_EXPR:
3310 case FLOAT_EXPR:
3311 CASE_CONVERT:
3312 case FIX_TRUNC_EXPR:
3313 case TARGET_EXPR:
3314 return 14;
3315
3316 case CALL_EXPR:
3317 case ARRAY_REF:
3318 case ARRAY_RANGE_REF:
3319 case COMPONENT_REF:
3320 return 15;
3321
3322 /* Special expressions. */
3323 case MIN_EXPR:
3324 case MAX_EXPR:
3325 case ABS_EXPR:
3326 case REALPART_EXPR:
3327 case IMAGPART_EXPR:
3328 case REDUC_MAX_EXPR:
3329 case REDUC_MIN_EXPR:
3330 case REDUC_PLUS_EXPR:
3331 case VEC_UNPACK_HI_EXPR:
3332 case VEC_UNPACK_LO_EXPR:
3333 case VEC_UNPACK_FLOAT_HI_EXPR:
3334 case VEC_UNPACK_FLOAT_LO_EXPR:
3335 case VEC_PACK_TRUNC_EXPR:
3336 case VEC_PACK_SAT_EXPR:
3337 return 16;
3338
3339 default:
3340 /* Return an arbitrarily high precedence to avoid surrounding single
3341 VAR_DECLs in ()s. */
3342 return 9999;
3343 }
3344 }
3345
3346 /* Return the priority of the operator OP. */
3347
3348 int
3349 op_prio (const_tree op)
3350 {
3351 enum tree_code code;
3352
3353 if (op == NULL)
3354 return 9999;
3355
3356 code = TREE_CODE (op);
3357 if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
3358 return op_prio (TREE_OPERAND (op, 0));
3359
3360 return op_code_prio (code);
3361 }
3362
3363 /* Return the symbol associated with operator CODE. */
3364
3365 const char *
3366 op_symbol_code (enum tree_code code)
3367 {
3368 switch (code)
3369 {
3370 case MODIFY_EXPR:
3371 return "=";
3372
3373 case TRUTH_OR_EXPR:
3374 case TRUTH_ORIF_EXPR:
3375 return "||";
3376
3377 case TRUTH_AND_EXPR:
3378 case TRUTH_ANDIF_EXPR:
3379 return "&&";
3380
3381 case BIT_IOR_EXPR:
3382 return "|";
3383
3384 case TRUTH_XOR_EXPR:
3385 case BIT_XOR_EXPR:
3386 return "^";
3387
3388 case ADDR_EXPR:
3389 case BIT_AND_EXPR:
3390 return "&";
3391
3392 case ORDERED_EXPR:
3393 return "ord";
3394 case UNORDERED_EXPR:
3395 return "unord";
3396
3397 case EQ_EXPR:
3398 return "==";
3399 case UNEQ_EXPR:
3400 return "u==";
3401
3402 case NE_EXPR:
3403 return "!=";
3404
3405 case LT_EXPR:
3406 return "<";
3407 case UNLT_EXPR:
3408 return "u<";
3409
3410 case LE_EXPR:
3411 return "<=";
3412 case UNLE_EXPR:
3413 return "u<=";
3414
3415 case GT_EXPR:
3416 return ">";
3417 case UNGT_EXPR:
3418 return "u>";
3419
3420 case GE_EXPR:
3421 return ">=";
3422 case UNGE_EXPR:
3423 return "u>=";
3424
3425 case LTGT_EXPR:
3426 return "<>";
3427
3428 case LSHIFT_EXPR:
3429 return "<<";
3430
3431 case RSHIFT_EXPR:
3432 return ">>";
3433
3434 case LROTATE_EXPR:
3435 return "r<<";
3436
3437 case RROTATE_EXPR:
3438 return "r>>";
3439
3440 case WIDEN_LSHIFT_EXPR:
3441 return "w<<";
3442
3443 case POINTER_PLUS_EXPR:
3444 return "+";
3445
3446 case PLUS_EXPR:
3447 return "+";
3448
3449 case REDUC_PLUS_EXPR:
3450 return "r+";
3451
3452 case WIDEN_SUM_EXPR:
3453 return "w+";
3454
3455 case WIDEN_MULT_EXPR:
3456 return "w*";
3457
3458 case MULT_HIGHPART_EXPR:
3459 return "h*";
3460
3461 case NEGATE_EXPR:
3462 case MINUS_EXPR:
3463 return "-";
3464
3465 case BIT_NOT_EXPR:
3466 return "~";
3467
3468 case TRUTH_NOT_EXPR:
3469 return "!";
3470
3471 case MULT_EXPR:
3472 case INDIRECT_REF:
3473 return "*";
3474
3475 case TRUNC_DIV_EXPR:
3476 case RDIV_EXPR:
3477 return "/";
3478
3479 case CEIL_DIV_EXPR:
3480 return "/[cl]";
3481
3482 case FLOOR_DIV_EXPR:
3483 return "/[fl]";
3484
3485 case ROUND_DIV_EXPR:
3486 return "/[rd]";
3487
3488 case EXACT_DIV_EXPR:
3489 return "/[ex]";
3490
3491 case TRUNC_MOD_EXPR:
3492 return "%";
3493
3494 case CEIL_MOD_EXPR:
3495 return "%[cl]";
3496
3497 case FLOOR_MOD_EXPR:
3498 return "%[fl]";
3499
3500 case ROUND_MOD_EXPR:
3501 return "%[rd]";
3502
3503 case PREDECREMENT_EXPR:
3504 return " --";
3505
3506 case PREINCREMENT_EXPR:
3507 return " ++";
3508
3509 case POSTDECREMENT_EXPR:
3510 return "-- ";
3511
3512 case POSTINCREMENT_EXPR:
3513 return "++ ";
3514
3515 case MAX_EXPR:
3516 return "max";
3517
3518 case MIN_EXPR:
3519 return "min";
3520
3521 default:
3522 return "<<< ??? >>>";
3523 }
3524 }
3525
3526 /* Return the symbol associated with operator OP. */
3527
3528 static const char *
3529 op_symbol (const_tree op)
3530 {
3531 return op_symbol_code (TREE_CODE (op));
3532 }
3533
3534 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3535 the gimple_call_fn of a GIMPLE_CALL. */
3536
3537 void
3538 print_call_name (pretty_printer *pp, tree node, int flags)
3539 {
3540 tree op0 = node;
3541
3542 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
3543 op0 = TREE_OPERAND (op0, 0);
3544
3545 again:
3546 switch (TREE_CODE (op0))
3547 {
3548 case VAR_DECL:
3549 case PARM_DECL:
3550 case FUNCTION_DECL:
3551 dump_function_name (pp, op0, flags);
3552 break;
3553
3554 case ADDR_EXPR:
3555 case INDIRECT_REF:
3556 CASE_CONVERT:
3557 op0 = TREE_OPERAND (op0, 0);
3558 goto again;
3559
3560 case COND_EXPR:
3561 pp_left_paren (pp);
3562 dump_generic_node (pp, TREE_OPERAND (op0, 0), 0, flags, false);
3563 pp_string (pp, ") ? ");
3564 dump_generic_node (pp, TREE_OPERAND (op0, 1), 0, flags, false);
3565 pp_string (pp, " : ");
3566 dump_generic_node (pp, TREE_OPERAND (op0, 2), 0, flags, false);
3567 break;
3568
3569 case ARRAY_REF:
3570 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
3571 dump_function_name (pp, TREE_OPERAND (op0, 0), flags);
3572 else
3573 dump_generic_node (pp, op0, 0, flags, false);
3574 break;
3575
3576 case MEM_REF:
3577 if (integer_zerop (TREE_OPERAND (op0, 1)))
3578 {
3579 op0 = TREE_OPERAND (op0, 0);
3580 goto again;
3581 }
3582 /* Fallthru. */
3583 case COMPONENT_REF:
3584 case SSA_NAME:
3585 case OBJ_TYPE_REF:
3586 dump_generic_node (pp, op0, 0, flags, false);
3587 break;
3588
3589 default:
3590 NIY;
3591 }
3592 }
3593
3594 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3595
3596 static void
3597 pretty_print_string (pretty_printer *pp, const char *str)
3598 {
3599 if (str == NULL)
3600 return;
3601
3602 while (*str)
3603 {
3604 switch (str[0])
3605 {
3606 case '\b':
3607 pp_string (pp, "\\b");
3608 break;
3609
3610 case '\f':
3611 pp_string (pp, "\\f");
3612 break;
3613
3614 case '\n':
3615 pp_string (pp, "\\n");
3616 break;
3617
3618 case '\r':
3619 pp_string (pp, "\\r");
3620 break;
3621
3622 case '\t':
3623 pp_string (pp, "\\t");
3624 break;
3625
3626 case '\v':
3627 pp_string (pp, "\\v");
3628 break;
3629
3630 case '\\':
3631 pp_string (pp, "\\\\");
3632 break;
3633
3634 case '\"':
3635 pp_string (pp, "\\\"");
3636 break;
3637
3638 case '\'':
3639 pp_string (pp, "\\'");
3640 break;
3641
3642 /* No need to handle \0; the loop terminates on \0. */
3643
3644 case '\1':
3645 pp_string (pp, "\\1");
3646 break;
3647
3648 case '\2':
3649 pp_string (pp, "\\2");
3650 break;
3651
3652 case '\3':
3653 pp_string (pp, "\\3");
3654 break;
3655
3656 case '\4':
3657 pp_string (pp, "\\4");
3658 break;
3659
3660 case '\5':
3661 pp_string (pp, "\\5");
3662 break;
3663
3664 case '\6':
3665 pp_string (pp, "\\6");
3666 break;
3667
3668 case '\7':
3669 pp_string (pp, "\\7");
3670 break;
3671
3672 default:
3673 pp_character (pp, str[0]);
3674 break;
3675 }
3676 str++;
3677 }
3678 }
3679
3680 static void
3681 maybe_init_pretty_print (FILE *file)
3682 {
3683 if (!tree_pp)
3684 {
3685 tree_pp = new pretty_printer ();
3686 pp_needs_newline (tree_pp) = true;
3687 pp_translate_identifiers (tree_pp) = false;
3688 }
3689
3690 tree_pp->buffer->stream = file;
3691 }
3692
3693 static void
3694 newline_and_indent (pretty_printer *pp, int spc)
3695 {
3696 pp_newline (pp);
3697 INDENT (spc);
3698 }
3699
3700 /* Handle a %K format for TEXT. Separate from default_tree_printer so
3701 it can also be used in front ends.
3702 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3703 */
3704
3705 void
3706 percent_K_format (text_info *text)
3707 {
3708 tree t = va_arg (*text->args_ptr, tree), block;
3709 text->set_location (0, EXPR_LOCATION (t));
3710 gcc_assert (pp_ti_abstract_origin (text) != NULL);
3711 block = TREE_BLOCK (t);
3712 *pp_ti_abstract_origin (text) = NULL;
3713
3714 if (in_lto_p)
3715 {
3716 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3717 representing the outermost block of an inlined function.
3718 So walk the BLOCK tree until we hit such a scope. */
3719 while (block
3720 && TREE_CODE (block) == BLOCK)
3721 {
3722 if (inlined_function_outer_scope_p (block))
3723 {
3724 *pp_ti_abstract_origin (text) = block;
3725 break;
3726 }
3727 block = BLOCK_SUPERCONTEXT (block);
3728 }
3729 return;
3730 }
3731
3732 while (block
3733 && TREE_CODE (block) == BLOCK
3734 && BLOCK_ABSTRACT_ORIGIN (block))
3735 {
3736 tree ao = BLOCK_ABSTRACT_ORIGIN (block);
3737
3738 while (TREE_CODE (ao) == BLOCK
3739 && BLOCK_ABSTRACT_ORIGIN (ao)
3740 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3741 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3742
3743 if (TREE_CODE (ao) == FUNCTION_DECL)
3744 {
3745 *pp_ti_abstract_origin (text) = block;
3746 break;
3747 }
3748 block = BLOCK_SUPERCONTEXT (block);
3749 }
3750 }
3751
3752 /* Print the identifier ID to PRETTY-PRINTER. */
3753
3754 void
3755 pp_tree_identifier (pretty_printer *pp, tree id)
3756 {
3757 if (pp_translate_identifiers (pp))
3758 {
3759 const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
3760 pp_append_text (pp, text, text + strlen (text));
3761 }
3762 else
3763 pp_append_text (pp, IDENTIFIER_POINTER (id),
3764 IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
3765 }
3766
3767 /* A helper function that is used to dump function information before the
3768 function dump. */
3769
3770 void
3771 dump_function_header (FILE *dump_file, tree fdecl, int flags)
3772 {
3773 const char *dname, *aname;
3774 struct cgraph_node *node = cgraph_node::get (fdecl);
3775 struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
3776
3777 dname = lang_hooks.decl_printable_name (fdecl, 2);
3778
3779 if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
3780 aname = (IDENTIFIER_POINTER
3781 (DECL_ASSEMBLER_NAME (fdecl)));
3782 else
3783 aname = "<unset-asm-name>";
3784
3785 fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
3786 dname, aname, fun->funcdef_no);
3787 if (!(flags & TDF_NOUID))
3788 fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
3789 if (node)
3790 {
3791 fprintf (dump_file, ", cgraph_uid=%d", node->uid);
3792 fprintf (dump_file, ", symbol_order=%d)%s\n\n", node->order,
3793 node->frequency == NODE_FREQUENCY_HOT
3794 ? " (hot)"
3795 : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
3796 ? " (unlikely executed)"
3797 : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
3798 ? " (executed once)"
3799 : "");
3800 }
3801 else
3802 fprintf (dump_file, ")\n\n");
3803 }
3804
3805 /* Dump double_int D to pretty_printer PP. UNS is true
3806 if D is unsigned and false otherwise. */
3807 void
3808 pp_double_int (pretty_printer *pp, double_int d, bool uns)
3809 {
3810 if (d.fits_shwi ())
3811 pp_wide_integer (pp, d.low);
3812 else if (d.fits_uhwi ())
3813 pp_unsigned_wide_integer (pp, d.low);
3814 else
3815 {
3816 unsigned HOST_WIDE_INT low = d.low;
3817 HOST_WIDE_INT high = d.high;
3818 if (!uns && d.is_negative ())
3819 {
3820 pp_minus (pp);
3821 high = ~high + !low;
3822 low = -low;
3823 }
3824 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
3825 systems? */
3826 sprintf (pp_buffer (pp)->digit_buffer,
3827 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3828 (unsigned HOST_WIDE_INT) high, low);
3829 pp_string (pp, pp_buffer (pp)->digit_buffer);
3830 }
3831 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org