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