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