?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
c++: improve verify_constant diagnostic [PR91483]
[official-gcc.git] / gcc / tree-pretty-print.cc
blob4491176a126df82f59d7b3ea9091cbbebf2d8e02
1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2023 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.cc 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 #include "gimple.h"
37 #include "fold-const.h"
38
39 /* Routines in this file get invoked via the default tree printer
40 used by diagnostics and thus they are called from pp_printf which
41 isn't reentrant. Avoid using pp_printf in this file. */
42 #pragma GCC poison pp_printf
43
44 /* Disable warnings about quoting issues in the pp_xxx calls below
45 that (intentionally) don't follow GCC diagnostic conventions. */
46 #if __GNUC__ >= 10
47 # pragma GCC diagnostic push
48 # pragma GCC diagnostic ignored "-Wformat-diag"
49 #endif
50
51 /* Local functions, macros and variables. */
52 static const char *op_symbol (const_tree);
53 static void newline_and_indent (pretty_printer *, int);
54 static void maybe_init_pretty_print (FILE *);
55 static void print_struct_decl (pretty_printer *, const_tree, int, dump_flags_t);
56 static void do_niy (pretty_printer *, const_tree, int, dump_flags_t);
57
58 #define INDENT(SPACE) do { \
59 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
60
61 #define NIY do_niy (pp, node, spc, flags)
62
63 static pretty_printer *tree_pp;
64
65 /* Try to print something for an unknown tree code. */
66
67 static void
68 do_niy (pretty_printer *pp, const_tree node, int spc, dump_flags_t flags)
69 {
70 int i, len;
71
72 pp_string (pp, "<<< Unknown tree: ");
73 pp_string (pp, get_tree_code_name (TREE_CODE (node)));
74
75 if (EXPR_P (node))
76 {
77 len = TREE_OPERAND_LENGTH (node);
78 for (i = 0; i < len; ++i)
79 {
80 newline_and_indent (pp, spc+2);
81 dump_generic_node (pp, TREE_OPERAND (node, i), spc+2, flags, false);
82 }
83 }
84
85 pp_string (pp, " >>>");
86 }
87
88 /* Debugging function to print out a generic expression. */
89
90 DEBUG_FUNCTION void
91 debug_generic_expr (tree t)
92 {
93 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
94 fprintf (stderr, "\n");
95 }
96
97 /* Debugging function to print out a generic statement. */
98
99 DEBUG_FUNCTION void
100 debug_generic_stmt (tree t)
101 {
102 print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
103 fprintf (stderr, "\n");
104 }
105
106 /* Debugging function to print out a chain of trees . */
107
108 DEBUG_FUNCTION void
109 debug_tree_chain (tree t)
110 {
111 hash_set<tree> seen;
112
113 while (t)
114 {
115 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
116 fprintf (stderr, " ");
117 t = TREE_CHAIN (t);
118 if (seen.add (t))
119 {
120 fprintf (stderr, "... [cycled back to ");
121 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
122 fprintf (stderr, "]");
123 break;
124 }
125 }
126 fprintf (stderr, "\n");
127 }
128
129 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
130 void
131 print_generic_decl (FILE *file, tree decl, dump_flags_t flags)
132 {
133 maybe_init_pretty_print (file);
134 print_declaration (tree_pp, decl, 2, flags);
135 pp_write_text_to_stream (tree_pp);
136 }
137
138 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
139 to show in the dump. See TDF_* in dumpfile.h. */
140
141 void
142 print_generic_stmt (FILE *file, tree t, dump_flags_t flags)
143 {
144 maybe_init_pretty_print (file);
145 dump_generic_node (tree_pp, t, 0, flags, true);
146 pp_newline_and_flush (tree_pp);
147 }
148
149 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
150 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
151 INDENT spaces. */
152
153 void
154 print_generic_stmt_indented (FILE *file, tree t, dump_flags_t flags, int indent)
155 {
156 int i;
157
158 maybe_init_pretty_print (file);
159
160 for (i = 0; i < indent; i++)
161 pp_space (tree_pp);
162 dump_generic_node (tree_pp, t, indent, flags, true);
163 pp_newline_and_flush (tree_pp);
164 }
165
166 /* Print a single expression T on file FILE. FLAGS specifies details to show
167 in the dump. See TDF_* in dumpfile.h. */
168
169 void
170 print_generic_expr (FILE *file, tree t, dump_flags_t flags)
171 {
172 maybe_init_pretty_print (file);
173 dump_generic_node (tree_pp, t, 0, flags, false);
174 pp_flush (tree_pp);
175 }
176
177 /* Print a single expression T to string, and return it. The caller
178 must free the returned memory. */
179
180 char *
181 print_generic_expr_to_str (tree t)
182 {
183 pretty_printer pp;
184 dump_generic_node (&pp, t, 0, TDF_VOPS|TDF_MEMSYMS, false);
185 return xstrdup (pp_formatted_text (&pp));
186 }
187
188 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
189 in it are replaced with Dxxxx, as long as they are at the start or
190 preceded by $ and at the end or followed by $. See make_fancy_name
191 in tree-sra.cc. */
192
193 static void
194 dump_fancy_name (pretty_printer *pp, tree name)
195 {
196 int cnt = 0;
197 int length = IDENTIFIER_LENGTH (name);
198 const char *n = IDENTIFIER_POINTER (name);
199 do
200 {
201 n = strchr (n, 'D');
202 if (n == NULL)
203 break;
204 if (ISDIGIT (n[1])
205 && (n == IDENTIFIER_POINTER (name) || n[-1] == '$'))
206 {
207 int l = 2;
208 while (ISDIGIT (n[l]))
209 l++;
210 if (n[l] == '\0' || n[l] == '$')
211 {
212 cnt++;
213 length += 5 - l;
214 }
215 n += l;
216 }
217 else
218 n++;
219 }
220 while (1);
221 if (cnt == 0)
222 {
223 pp_tree_identifier (pp, name);
224 return;
225 }
226
227 char *str = XNEWVEC (char, length + 1);
228 char *p = str;
229 const char *q;
230 q = n = IDENTIFIER_POINTER (name);
231 do
232 {
233 q = strchr (q, 'D');
234 if (q == NULL)
235 break;
236 if (ISDIGIT (q[1])
237 && (q == IDENTIFIER_POINTER (name) || q[-1] == '$'))
238 {
239 int l = 2;
240 while (ISDIGIT (q[l]))
241 l++;
242 if (q[l] == '\0' || q[l] == '$')
243 {
244 memcpy (p, n, q - n);
245 memcpy (p + (q - n), "Dxxxx", 5);
246 p += (q - n) + 5;
247 n = q + l;
248 }
249 q += l;
250 }
251 else
252 q++;
253 }
254 while (1);
255 memcpy (p, n, IDENTIFIER_LENGTH (name) - (n - IDENTIFIER_POINTER (name)));
256 str[length] = '\0';
257 if (pp_translate_identifiers (pp))
258 {
259 const char *text = identifier_to_locale (str);
260 pp_append_text (pp, text, text + strlen (text));
261 }
262 else
263 pp_append_text (pp, str, str + length);
264 XDELETEVEC (str);
265 }
266
267 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
268 in FLAGS. */
269
270 static void
271 dump_decl_name (pretty_printer *pp, tree node, dump_flags_t flags)
272 {
273 tree name = DECL_NAME (node);
274 if (name)
275 {
276 if ((flags & TDF_ASMNAME)
277 && HAS_DECL_ASSEMBLER_NAME_P (node)
278 && DECL_ASSEMBLER_NAME_SET_P (node))
279 pp_tree_identifier (pp, DECL_ASSEMBLER_NAME_RAW (node));
280 /* For -fcompare-debug don't dump DECL_NAMELESS names at all,
281 -g might have created more fancy names and their indexes
282 could get out of sync. Usually those should be DECL_IGNORED_P
283 too, SRA can create even non-DECL_IGNORED_P DECL_NAMELESS fancy
284 names, let's hope those never get out of sync after doing the
285 dump_fancy_name sanitization. */
286 else if ((flags & TDF_COMPARE_DEBUG)
287 && DECL_NAMELESS (node)
288 && DECL_IGNORED_P (node))
289 name = NULL_TREE;
290 /* For DECL_NAMELESS names look for embedded uids in the
291 names and sanitize them for TDF_NOUID. */
292 else if ((flags & TDF_NOUID) && DECL_NAMELESS (node))
293 dump_fancy_name (pp, name);
294 else
295 pp_tree_identifier (pp, name);
296 }
297 char uid_sep = (flags & TDF_GIMPLE) ? '_' : '.';
298 if ((flags & TDF_UID) || name == NULL_TREE)
299 {
300 if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)
301 {
302 pp_character (pp, 'L');
303 pp_character (pp, uid_sep);
304 pp_decimal_int (pp, (int) LABEL_DECL_UID (node));
305 }
306 else if (TREE_CODE (node) == DEBUG_EXPR_DECL)
307 {
308 if (flags & TDF_NOUID)
309 pp_string (pp, "D#xxxx");
310 else
311 {
312 pp_string (pp, "D#");
313 pp_decimal_int (pp, (int) DEBUG_TEMP_UID (node));
314 }
315 }
316 else
317 {
318 char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
319 pp_character (pp, c);
320 pp_character (pp, uid_sep);
321 if (flags & TDF_NOUID)
322 pp_string (pp, "xxxx");
323 else
324 pp_scalar (pp, "%u", DECL_UID (node));
325 }
326 }
327 if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node))
328 {
329 if (flags & TDF_NOUID)
330 pp_string (pp, "ptD.xxxx");
331 else
332 {
333 pp_string (pp, "ptD.");
334 pp_scalar (pp, "%u", DECL_PT_UID (node));
335 }
336 }
337 }
338
339 /* Like the above, but used for pretty printing function calls. */
340
341 static void
342 dump_function_name (pretty_printer *pp, tree node, dump_flags_t flags)
343 {
344 if (CONVERT_EXPR_P (node))
345 node = TREE_OPERAND (node, 0);
346 if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)
347 {
348 pp_string (pp, lang_hooks.decl_printable_name (node, 1));
349 if (flags & TDF_UID)
350 {
351 char uid_sep = (flags & TDF_GIMPLE) ? '_' : '.';
352 pp_character (pp, 'D');
353 pp_character (pp, uid_sep);
354 pp_scalar (pp, "%u", DECL_UID (node));
355 }
356 }
357 else
358 dump_decl_name (pp, node, flags);
359 }
360
361 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
362 FLAGS are as in dump_generic_node. */
363
364 static void
365 dump_function_declaration (pretty_printer *pp, tree node,
366 int spc, dump_flags_t flags)
367 {
368 bool wrote_arg = false;
369 tree arg;
370
371 pp_space (pp);
372 pp_left_paren (pp);
373
374 /* Print the argument types. */
375 arg = TYPE_ARG_TYPES (node);
376 while (arg && arg != void_list_node && arg != error_mark_node)
377 {
378 if (wrote_arg)
379 {
380 pp_comma (pp);
381 pp_space (pp);
382 }
383 wrote_arg = true;
384 dump_generic_node (pp, TREE_VALUE (arg), spc, flags, false);
385 arg = TREE_CHAIN (arg);
386 }
387
388 /* Drop the trailing void_type_node if we had any previous argument. */
389 if (arg == void_list_node && !wrote_arg)
390 pp_string (pp, "void");
391 /* Properly dump vararg function types. */
392 else if (!arg && wrote_arg)
393 pp_string (pp, ", ...");
394 /* Avoid printing any arg for unprototyped functions. */
395
396 pp_right_paren (pp);
397 }
398
399 /* Dump the domain associated with an array. */
400
401 static void
402 dump_array_domain (pretty_printer *pp, tree domain, int spc, dump_flags_t flags)
403 {
404 pp_left_bracket (pp);
405 if (domain)
406 {
407 tree min = TYPE_MIN_VALUE (domain);
408 tree max = TYPE_MAX_VALUE (domain);
409
410 if (min && max
411 && integer_zerop (min)
412 && tree_fits_shwi_p (max))
413 pp_wide_integer (pp, tree_to_shwi (max) + 1);
414 else
415 {
416 if (min)
417 dump_generic_node (pp, min, spc, flags, false);
418 pp_colon (pp);
419 if (max)
420 dump_generic_node (pp, max, spc, flags, false);
421 }
422 }
423 else
424 pp_string (pp, "<unknown>");
425 pp_right_bracket (pp);
426 }
427
428
429 /* Dump OpenMP iterators ITER. */
430
431 static void
432 dump_omp_iterators (pretty_printer *pp, tree iter, int spc, dump_flags_t flags)
433 {
434 pp_string (pp, "iterator(");
435 for (tree it = iter; it; it = TREE_CHAIN (it))
436 {
437 if (it != iter)
438 pp_string (pp, ", ");
439 dump_generic_node (pp, TREE_TYPE (TREE_VEC_ELT (it, 0)), spc, flags,
440 false);
441 pp_space (pp);
442 dump_generic_node (pp, TREE_VEC_ELT (it, 0), spc, flags, false);
443 pp_equal (pp);
444 dump_generic_node (pp, TREE_VEC_ELT (it, 1), spc, flags, false);
445 pp_colon (pp);
446 dump_generic_node (pp, TREE_VEC_ELT (it, 2), spc, flags, false);
447 pp_colon (pp);
448 dump_generic_node (pp, TREE_VEC_ELT (it, 3), spc, flags, false);
449 }
450 pp_right_paren (pp);
451 }
452
453
454 /* Dump OMP clause CLAUSE, without following OMP_CLAUSE_CHAIN.
455
456 PP, CLAUSE, SPC and FLAGS are as in dump_generic_node. */
457
458 static void
459 dump_omp_clause (pretty_printer *pp, tree clause, int spc, dump_flags_t flags)
460 {
461 const char *name;
462 const char *modifier = NULL;
463 switch (OMP_CLAUSE_CODE (clause))
464 {
465 case OMP_CLAUSE_PRIVATE:
466 name = "private";
467 goto print_remap;
468 case OMP_CLAUSE_SHARED:
469 name = "shared";
470 goto print_remap;
471 case OMP_CLAUSE_FIRSTPRIVATE:
472 name = "firstprivate";
473 goto print_remap;
474 case OMP_CLAUSE_LASTPRIVATE:
475 name = "lastprivate";
476 if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clause))
477 modifier = "conditional:";
478 goto print_remap;
479 case OMP_CLAUSE_COPYIN:
480 name = "copyin";
481 goto print_remap;
482 case OMP_CLAUSE_COPYPRIVATE:
483 name = "copyprivate";
484 goto print_remap;
485 case OMP_CLAUSE_UNIFORM:
486 name = "uniform";
487 goto print_remap;
488 case OMP_CLAUSE_USE_DEVICE_PTR:
489 name = "use_device_ptr";
490 if (OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT (clause))
491 modifier = "if_present:";
492 goto print_remap;
493 case OMP_CLAUSE_USE_DEVICE_ADDR:
494 name = "use_device_addr";
495 goto print_remap;
496 case OMP_CLAUSE_HAS_DEVICE_ADDR:
497 name = "has_device_addr";
498 goto print_remap;
499 case OMP_CLAUSE_IS_DEVICE_PTR:
500 name = "is_device_ptr";
501 goto print_remap;
502 case OMP_CLAUSE_INCLUSIVE:
503 name = "inclusive";
504 goto print_remap;
505 case OMP_CLAUSE_EXCLUSIVE:
506 name = "exclusive";
507 goto print_remap;
508 case OMP_CLAUSE__LOOPTEMP_:
509 name = "_looptemp_";
510 goto print_remap;
511 case OMP_CLAUSE__REDUCTEMP_:
512 name = "_reductemp_";
513 goto print_remap;
514 case OMP_CLAUSE__CONDTEMP_:
515 name = "_condtemp_";
516 goto print_remap;
517 case OMP_CLAUSE__SCANTEMP_:
518 name = "_scantemp_";
519 goto print_remap;
520 case OMP_CLAUSE_ENTER:
521 if (OMP_CLAUSE_ENTER_TO (clause))
522 name = "to";
523 else
524 name = "enter";
525 goto print_remap;
526 case OMP_CLAUSE_LINK:
527 name = "link";
528 goto print_remap;
529 case OMP_CLAUSE_NONTEMPORAL:
530 name = "nontemporal";
531 goto print_remap;
532 print_remap:
533 pp_string (pp, name);
534 pp_left_paren (pp);
535 if (modifier)
536 pp_string (pp, modifier);
537 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
538 spc, flags, false);
539 pp_right_paren (pp);
540 break;
541
542 case OMP_CLAUSE_TASK_REDUCTION:
543 case OMP_CLAUSE_IN_REDUCTION:
544 pp_string (pp, OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_IN_REDUCTION
545 ? "in_" : "task_");
546 /* FALLTHRU */
547 case OMP_CLAUSE_REDUCTION:
548 pp_string (pp, "reduction(");
549 if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_REDUCTION)
550 {
551 if (OMP_CLAUSE_REDUCTION_TASK (clause))
552 pp_string (pp, "task,");
553 else if (OMP_CLAUSE_REDUCTION_INSCAN (clause))
554 pp_string (pp, "inscan,");
555 }
556 if (OMP_CLAUSE_REDUCTION_CODE (clause) != ERROR_MARK)
557 {
558 pp_string (pp,
559 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
560 pp_colon (pp);
561 }
562 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
563 spc, flags, false);
564 pp_right_paren (pp);
565 break;
566
567 case OMP_CLAUSE_IF:
568 pp_string (pp, "if(");
569 switch (OMP_CLAUSE_IF_MODIFIER (clause))
570 {
571 case ERROR_MARK: break;
572 case VOID_CST: pp_string (pp, "cancel:"); break;
573 case OMP_PARALLEL: pp_string (pp, "parallel:"); break;
574 case OMP_SIMD: pp_string (pp, "simd:"); break;
575 case OMP_TASK: pp_string (pp, "task:"); break;
576 case OMP_TASKLOOP: pp_string (pp, "taskloop:"); break;
577 case OMP_TARGET_DATA: pp_string (pp, "target data:"); break;
578 case OMP_TARGET: pp_string (pp, "target:"); break;
579 case OMP_TARGET_UPDATE: pp_string (pp, "target update:"); break;
580 case OMP_TARGET_ENTER_DATA:
581 pp_string (pp, "target enter data:"); break;
582 case OMP_TARGET_EXIT_DATA: pp_string (pp, "target exit data:"); break;
583 default: gcc_unreachable ();
584 }
585 dump_generic_node (pp, OMP_CLAUSE_IF_EXPR (clause),
586 spc, flags, false);
587 pp_right_paren (pp);
588 break;
589
590 case OMP_CLAUSE_NUM_THREADS:
591 pp_string (pp, "num_threads(");
592 dump_generic_node (pp, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
593 spc, flags, false);
594 pp_right_paren (pp);
595 break;
596
597 case OMP_CLAUSE_NOWAIT:
598 pp_string (pp, "nowait");
599 break;
600 case OMP_CLAUSE_ORDERED:
601 pp_string (pp, "ordered");
602 if (OMP_CLAUSE_ORDERED_EXPR (clause))
603 {
604 pp_left_paren (pp);
605 dump_generic_node (pp, OMP_CLAUSE_ORDERED_EXPR (clause),
606 spc, flags, false);
607 pp_right_paren (pp);
608 }
609 break;
610
611 case OMP_CLAUSE_DEFAULT:
612 pp_string (pp, "default(");
613 switch (OMP_CLAUSE_DEFAULT_KIND (clause))
614 {
615 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
616 break;
617 case OMP_CLAUSE_DEFAULT_SHARED:
618 pp_string (pp, "shared");
619 break;
620 case OMP_CLAUSE_DEFAULT_NONE:
621 pp_string (pp, "none");
622 break;
623 case OMP_CLAUSE_DEFAULT_PRIVATE:
624 pp_string (pp, "private");
625 break;
626 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
627 pp_string (pp, "firstprivate");
628 break;
629 case OMP_CLAUSE_DEFAULT_PRESENT:
630 pp_string (pp, "present");
631 break;
632 default:
633 gcc_unreachable ();
634 }
635 pp_right_paren (pp);
636 break;
637
638 case OMP_CLAUSE_SCHEDULE:
639 pp_string (pp, "schedule(");
640 if (OMP_CLAUSE_SCHEDULE_KIND (clause)
641 & (OMP_CLAUSE_SCHEDULE_MONOTONIC
642 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC))
643 {
644 if (OMP_CLAUSE_SCHEDULE_KIND (clause)
645 & OMP_CLAUSE_SCHEDULE_MONOTONIC)
646 pp_string (pp, "monotonic");
647 else
648 pp_string (pp, "nonmonotonic");
649 if (OMP_CLAUSE_SCHEDULE_SIMD (clause))
650 pp_comma (pp);
651 else
652 pp_colon (pp);
653 }
654 if (OMP_CLAUSE_SCHEDULE_SIMD (clause))
655 pp_string (pp, "simd:");
656
657 switch (OMP_CLAUSE_SCHEDULE_KIND (clause) & OMP_CLAUSE_SCHEDULE_MASK)
658 {
659 case OMP_CLAUSE_SCHEDULE_STATIC:
660 pp_string (pp, "static");
661 break;
662 case OMP_CLAUSE_SCHEDULE_DYNAMIC:
663 pp_string (pp, "dynamic");
664 break;
665 case OMP_CLAUSE_SCHEDULE_GUIDED:
666 pp_string (pp, "guided");
667 break;
668 case OMP_CLAUSE_SCHEDULE_RUNTIME:
669 pp_string (pp, "runtime");
670 break;
671 case OMP_CLAUSE_SCHEDULE_AUTO:
672 pp_string (pp, "auto");
673 break;
674 default:
675 gcc_unreachable ();
676 }
677 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
678 {
679 pp_comma (pp);
680 dump_generic_node (pp, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
681 spc, flags, false);
682 }
683 pp_right_paren (pp);
684 break;
685
686 case OMP_CLAUSE_UNTIED:
687 pp_string (pp, "untied");
688 break;
689
690 case OMP_CLAUSE_COLLAPSE:
691 pp_string (pp, "collapse(");
692 dump_generic_node (pp, OMP_CLAUSE_COLLAPSE_EXPR (clause),
693 spc, flags, false);
694 pp_right_paren (pp);
695 break;
696
697 case OMP_CLAUSE_FINAL:
698 pp_string (pp, "final(");
699 dump_generic_node (pp, OMP_CLAUSE_FINAL_EXPR (clause),
700 spc, flags, false);
701 pp_right_paren (pp);
702 break;
703
704 case OMP_CLAUSE_MERGEABLE:
705 pp_string (pp, "mergeable");
706 break;
707
708 case OMP_CLAUSE_LINEAR:
709 pp_string (pp, "linear(");
710 if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause))
711 switch (OMP_CLAUSE_LINEAR_KIND (clause))
712 {
713 case OMP_CLAUSE_LINEAR_DEFAULT:
714 break;
715 case OMP_CLAUSE_LINEAR_REF:
716 pp_string (pp, "ref(");
717 break;
718 case OMP_CLAUSE_LINEAR_VAL:
719 pp_string (pp, "val(");
720 break;
721 case OMP_CLAUSE_LINEAR_UVAL:
722 pp_string (pp, "uval(");
723 break;
724 default:
725 gcc_unreachable ();
726 }
727 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
728 spc, flags, false);
729 if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
730 && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
731 pp_right_paren (pp);
732 pp_colon (pp);
733 if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
734 && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
735 switch (OMP_CLAUSE_LINEAR_KIND (clause))
736 {
737 case OMP_CLAUSE_LINEAR_REF:
738 pp_string (pp, "ref,step(");
739 break;
740 case OMP_CLAUSE_LINEAR_VAL:
741 pp_string (pp, "val,step(");
742 break;
743 case OMP_CLAUSE_LINEAR_UVAL:
744 pp_string (pp, "uval,step(");
745 break;
746 default:
747 gcc_unreachable ();
748 }
749 dump_generic_node (pp, OMP_CLAUSE_LINEAR_STEP (clause),
750 spc, flags, false);
751 if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
752 && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
753 pp_right_paren (pp);
754 pp_right_paren (pp);
755 break;
756
757 case OMP_CLAUSE_ALIGNED:
758 pp_string (pp, "aligned(");
759 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
760 spc, flags, false);
761 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause))
762 {
763 pp_colon (pp);
764 dump_generic_node (pp, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause),
765 spc, flags, false);
766 }
767 pp_right_paren (pp);
768 break;
769
770 case OMP_CLAUSE_ALLOCATE:
771 pp_string (pp, "allocate(");
772 if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause))
773 {
774 pp_string (pp, "allocator(");
775 dump_generic_node (pp, OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause),
776 spc, flags, false);
777 pp_right_paren (pp);
778 }
779 if (OMP_CLAUSE_ALLOCATE_ALIGN (clause))
780 {
781 if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause))
782 pp_comma (pp);
783 pp_string (pp, "align(");
784 dump_generic_node (pp, OMP_CLAUSE_ALLOCATE_ALIGN (clause),
785 spc, flags, false);
786 pp_right_paren (pp);
787 }
788 if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause)
789 || OMP_CLAUSE_ALLOCATE_ALIGN (clause))
790 pp_colon (pp);
791 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
792 spc, flags, false);
793 pp_right_paren (pp);
794 break;
795
796 case OMP_CLAUSE_AFFINITY:
797 pp_string (pp, "affinity(");
798 {
799 tree t = OMP_CLAUSE_DECL (clause);
800 if (TREE_CODE (t) == TREE_LIST
801 && TREE_PURPOSE (t)
802 && TREE_CODE (TREE_PURPOSE (t)) == TREE_VEC)
803 {
804 dump_omp_iterators (pp, TREE_PURPOSE (t), spc, flags);
805 pp_colon (pp);
806 t = TREE_VALUE (t);
807 }
808 dump_generic_node (pp, t, spc, flags, false);
809 }
810 pp_right_paren (pp);
811 break;
812 case OMP_CLAUSE_DEPEND:
813 pp_string (pp, "depend(");
814 switch (OMP_CLAUSE_DEPEND_KIND (clause))
815 {
816 case OMP_CLAUSE_DEPEND_DEPOBJ:
817 name = "depobj";
818 break;
819 case OMP_CLAUSE_DEPEND_IN:
820 name = "in";
821 break;
822 case OMP_CLAUSE_DEPEND_OUT:
823 name = "out";
824 break;
825 case OMP_CLAUSE_DEPEND_INOUT:
826 name = "inout";
827 break;
828 case OMP_CLAUSE_DEPEND_MUTEXINOUTSET:
829 name = "mutexinoutset";
830 break;
831 case OMP_CLAUSE_DEPEND_INOUTSET:
832 name = "inoutset";
833 break;
834 case OMP_CLAUSE_DEPEND_LAST:
835 name = "__internal__";
836 break;
837 default:
838 gcc_unreachable ();
839 }
840 {
841 tree t = OMP_CLAUSE_DECL (clause);
842 if (TREE_CODE (t) == TREE_LIST
843 && TREE_PURPOSE (t)
844 && TREE_CODE (TREE_PURPOSE (t)) == TREE_VEC)
845 {
846 dump_omp_iterators (pp, TREE_PURPOSE (t), spc, flags);
847 pp_colon (pp);
848 t = TREE_VALUE (t);
849 }
850 if (name[0])
851 {
852 pp_string (pp, name);
853 pp_colon (pp);
854 }
855 if (t == null_pointer_node)
856 pp_string (pp, "omp_all_memory");
857 else
858 dump_generic_node (pp, t, spc, flags, false);
859 pp_right_paren (pp);
860 }
861 break;
862
863 case OMP_CLAUSE_DOACROSS:
864 pp_string (pp, OMP_CLAUSE_DOACROSS_DEPEND (clause)
865 ? "depend(" : "doacross(");
866 switch (OMP_CLAUSE_DOACROSS_KIND (clause))
867 {
868 case OMP_CLAUSE_DOACROSS_SOURCE:
869 if (OMP_CLAUSE_DOACROSS_DEPEND (clause))
870 pp_string (pp, "source)");
871 else
872 pp_string (pp, "source:)");
873 break;
874 case OMP_CLAUSE_DOACROSS_SINK:
875 pp_string (pp, "sink:");
876 if (OMP_CLAUSE_DECL (clause) == NULL_TREE)
877 {
878 pp_string (pp, "omp_cur_iteration-1)");
879 break;
880 }
881 for (tree t = OMP_CLAUSE_DECL (clause); t; t = TREE_CHAIN (t))
882 if (TREE_CODE (t) == TREE_LIST)
883 {
884 dump_generic_node (pp, TREE_VALUE (t), spc, flags, false);
885 if (TREE_PURPOSE (t) != integer_zero_node)
886 {
887 if (OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (t))
888 pp_minus (pp);
889 else
890 pp_plus (pp);
891 dump_generic_node (pp, TREE_PURPOSE (t), spc, flags,
892 false);
893 }
894 if (TREE_CHAIN (t))
895 pp_comma (pp);
896 }
897 else
898 gcc_unreachable ();
899 pp_right_paren (pp);
900 break;
901 default:
902 gcc_unreachable ();
903 }
904 break;
905
906 case OMP_CLAUSE_MAP:
907 pp_string (pp, "map(");
908 switch (OMP_CLAUSE_MAP_KIND (clause))
909 {
910 case GOMP_MAP_ALLOC:
911 case GOMP_MAP_POINTER:
912 case GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION:
913 pp_string (pp, "alloc");
914 break;
915 case GOMP_MAP_IF_PRESENT:
916 pp_string (pp, "no_alloc");
917 break;
918 case GOMP_MAP_TO:
919 case GOMP_MAP_TO_PSET:
920 pp_string (pp, "to");
921 break;
922 case GOMP_MAP_FROM:
923 pp_string (pp, "from");
924 break;
925 case GOMP_MAP_TOFROM:
926 pp_string (pp, "tofrom");
927 break;
928 case GOMP_MAP_FORCE_ALLOC:
929 pp_string (pp, "force_alloc");
930 break;
931 case GOMP_MAP_FORCE_TO:
932 pp_string (pp, "force_to");
933 break;
934 case GOMP_MAP_FORCE_FROM:
935 pp_string (pp, "force_from");
936 break;
937 case GOMP_MAP_FORCE_TOFROM:
938 pp_string (pp, "force_tofrom");
939 break;
940 case GOMP_MAP_FORCE_PRESENT:
941 pp_string (pp, "force_present");
942 break;
943 case GOMP_MAP_DELETE:
944 pp_string (pp, "delete");
945 break;
946 case GOMP_MAP_FORCE_DEVICEPTR:
947 pp_string (pp, "force_deviceptr");
948 break;
949 case GOMP_MAP_ALWAYS_TO:
950 pp_string (pp, "always,to");
951 break;
952 case GOMP_MAP_ALWAYS_FROM:
953 pp_string (pp, "always,from");
954 break;
955 case GOMP_MAP_ALWAYS_TOFROM:
956 pp_string (pp, "always,tofrom");
957 break;
958 case GOMP_MAP_RELEASE:
959 pp_string (pp, "release");
960 break;
961 case GOMP_MAP_FIRSTPRIVATE_POINTER:
962 pp_string (pp, "firstprivate");
963 break;
964 case GOMP_MAP_FIRSTPRIVATE_REFERENCE:
965 pp_string (pp, "firstprivate ref");
966 break;
967 case GOMP_MAP_STRUCT:
968 pp_string (pp, "struct");
969 break;
970 case GOMP_MAP_ALWAYS_POINTER:
971 pp_string (pp, "always_pointer");
972 break;
973 case GOMP_MAP_DEVICE_RESIDENT:
974 pp_string (pp, "device_resident");
975 break;
976 case GOMP_MAP_LINK:
977 pp_string (pp, "link");
978 break;
979 case GOMP_MAP_ATTACH:
980 pp_string (pp, "attach");
981 break;
982 case GOMP_MAP_DETACH:
983 pp_string (pp, "detach");
984 break;
985 case GOMP_MAP_FORCE_DETACH:
986 pp_string (pp, "force_detach");
987 break;
988 case GOMP_MAP_ATTACH_DETACH:
989 pp_string (pp, "attach_detach");
990 break;
991 case GOMP_MAP_ATTACH_ZERO_LENGTH_ARRAY_SECTION:
992 pp_string (pp, "attach_zero_length_array_section");
993 break;
994 case GOMP_MAP_PRESENT_ALLOC:
995 pp_string (pp, "present,alloc");
996 break;
997 case GOMP_MAP_PRESENT_TO:
998 pp_string (pp, "present,to");
999 break;
1000 case GOMP_MAP_PRESENT_FROM:
1001 pp_string (pp, "present,from");
1002 break;
1003 case GOMP_MAP_PRESENT_TOFROM:
1004 pp_string (pp, "present,tofrom");
1005 break;
1006 case GOMP_MAP_ALWAYS_PRESENT_TO:
1007 pp_string (pp, "always,present,to");
1008 break;
1009 case GOMP_MAP_ALWAYS_PRESENT_FROM:
1010 pp_string (pp, "always,present,from");
1011 break;
1012 case GOMP_MAP_ALWAYS_PRESENT_TOFROM:
1013 pp_string (pp, "always,present,tofrom");
1014 break;
1015 default:
1016 gcc_unreachable ();
1017 }
1018 pp_colon (pp);
1019 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
1020 spc, flags, false);
1021 print_clause_size:
1022 if (OMP_CLAUSE_SIZE (clause))
1023 {
1024 switch (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
1025 ? OMP_CLAUSE_MAP_KIND (clause) : GOMP_MAP_TO)
1026 {
1027 case GOMP_MAP_POINTER:
1028 case GOMP_MAP_FIRSTPRIVATE_POINTER:
1029 case GOMP_MAP_FIRSTPRIVATE_REFERENCE:
1030 case GOMP_MAP_ALWAYS_POINTER:
1031 pp_string (pp, " [pointer assign, bias: ");
1032 break;
1033 case GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION:
1034 pp_string (pp, " [pointer assign, zero-length array section, bias: ");
1035 break;
1036 case GOMP_MAP_TO_PSET:
1037 pp_string (pp, " [pointer set, len: ");
1038 break;
1039 case GOMP_MAP_ATTACH:
1040 case GOMP_MAP_DETACH:
1041 case GOMP_MAP_FORCE_DETACH:
1042 case GOMP_MAP_ATTACH_DETACH:
1043 case GOMP_MAP_ATTACH_ZERO_LENGTH_ARRAY_SECTION:
1044 pp_string (pp, " [bias: ");
1045 break;
1046 default:
1047 pp_string (pp, " [len: ");
1048 break;
1049 }
1050 dump_generic_node (pp, OMP_CLAUSE_SIZE (clause),
1051 spc, flags, false);
1052 pp_right_bracket (pp);
1053 }
1054 if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
1055 && OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P (clause))
1056 pp_string (pp, "[implicit]");
1057 pp_right_paren (pp);
1058 break;
1059
1060 case OMP_CLAUSE_FROM:
1061 pp_string (pp, "from(");
1062 if (OMP_CLAUSE_MOTION_PRESENT (clause))
1063 pp_string (pp, "present:");
1064 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
1065 spc, flags, false);
1066 goto print_clause_size;
1067
1068 case OMP_CLAUSE_TO:
1069 pp_string (pp, "to(");
1070 if (OMP_CLAUSE_MOTION_PRESENT (clause))
1071 pp_string (pp, "present:");
1072 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
1073 spc, flags, false);
1074 goto print_clause_size;
1075
1076 case OMP_CLAUSE__CACHE_:
1077 pp_string (pp, "(");
1078 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
1079 spc, flags, false);
1080 goto print_clause_size;
1081
1082 case OMP_CLAUSE_NUM_TEAMS:
1083 pp_string (pp, "num_teams(");
1084 if (OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (clause))
1085 {
1086 dump_generic_node (pp, OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (clause),
1087 spc, flags, false);
1088 pp_colon (pp);
1089 }
1090 dump_generic_node (pp, OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR (clause),
1091 spc, flags, false);
1092 pp_right_paren (pp);
1093 break;
1094
1095 case OMP_CLAUSE_THREAD_LIMIT:
1096 pp_string (pp, "thread_limit(");
1097 dump_generic_node (pp, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause),
1098 spc, flags, false);
1099 pp_right_paren (pp);
1100 break;
1101
1102 case OMP_CLAUSE_DEVICE:
1103 pp_string (pp, "device(");
1104 if (OMP_CLAUSE_DEVICE_ANCESTOR (clause))
1105 pp_string (pp, "ancestor:");
1106 dump_generic_node (pp, OMP_CLAUSE_DEVICE_ID (clause),
1107 spc, flags, false);
1108 pp_right_paren (pp);
1109 break;
1110
1111 case OMP_CLAUSE_DIST_SCHEDULE:
1112 pp_string (pp, "dist_schedule(static");
1113 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause))
1114 {
1115 pp_comma (pp);
1116 dump_generic_node (pp,
1117 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause),
1118 spc, flags, false);
1119 }
1120 pp_right_paren (pp);
1121 break;
1122
1123 case OMP_CLAUSE_PROC_BIND:
1124 pp_string (pp, "proc_bind(");
1125 switch (OMP_CLAUSE_PROC_BIND_KIND (clause))
1126 {
1127 case OMP_CLAUSE_PROC_BIND_MASTER:
1128 /* Same enum value: case OMP_CLAUSE_PROC_BIND_PRIMARY: */
1129 /* TODO: Change to 'primary' for OpenMP 5.1. */
1130 pp_string (pp, "master");
1131 break;
1132 case OMP_CLAUSE_PROC_BIND_CLOSE:
1133 pp_string (pp, "close");
1134 break;
1135 case OMP_CLAUSE_PROC_BIND_SPREAD:
1136 pp_string (pp, "spread");
1137 break;
1138 default:
1139 gcc_unreachable ();
1140 }
1141 pp_right_paren (pp);
1142 break;
1143
1144 case OMP_CLAUSE_DEVICE_TYPE:
1145 pp_string (pp, "device_type(");
1146 switch (OMP_CLAUSE_DEVICE_TYPE_KIND (clause))
1147 {
1148 case OMP_CLAUSE_DEVICE_TYPE_HOST:
1149 pp_string (pp, "host");
1150 break;
1151 case OMP_CLAUSE_DEVICE_TYPE_NOHOST:
1152 pp_string (pp, "nohost");
1153 break;
1154 case OMP_CLAUSE_DEVICE_TYPE_ANY:
1155 pp_string (pp, "any");
1156 break;
1157 default:
1158 gcc_unreachable ();
1159 }
1160 pp_right_paren (pp);
1161 break;
1162
1163 case OMP_CLAUSE_SAFELEN:
1164 pp_string (pp, "safelen(");
1165 dump_generic_node (pp, OMP_CLAUSE_SAFELEN_EXPR (clause),
1166 spc, flags, false);
1167 pp_right_paren (pp);
1168 break;
1169
1170 case OMP_CLAUSE_SIMDLEN:
1171 pp_string (pp, "simdlen(");
1172 dump_generic_node (pp, OMP_CLAUSE_SIMDLEN_EXPR (clause),
1173 spc, flags, false);
1174 pp_right_paren (pp);
1175 break;
1176
1177 case OMP_CLAUSE_PRIORITY:
1178 pp_string (pp, "priority(");
1179 dump_generic_node (pp, OMP_CLAUSE_PRIORITY_EXPR (clause),
1180 spc, flags, false);
1181 pp_right_paren (pp);
1182 break;
1183
1184 case OMP_CLAUSE_GRAINSIZE:
1185 pp_string (pp, "grainsize(");
1186 if (OMP_CLAUSE_GRAINSIZE_STRICT (clause))
1187 pp_string (pp, "strict:");
1188 dump_generic_node (pp, OMP_CLAUSE_GRAINSIZE_EXPR (clause),
1189 spc, flags, false);
1190 pp_right_paren (pp);
1191 break;
1192
1193 case OMP_CLAUSE_NUM_TASKS:
1194 pp_string (pp, "num_tasks(");
1195 if (OMP_CLAUSE_NUM_TASKS_STRICT (clause))
1196 pp_string (pp, "strict:");
1197 dump_generic_node (pp, OMP_CLAUSE_NUM_TASKS_EXPR (clause),
1198 spc, flags, false);
1199 pp_right_paren (pp);
1200 break;
1201
1202 case OMP_CLAUSE_HINT:
1203 pp_string (pp, "hint(");
1204 dump_generic_node (pp, OMP_CLAUSE_HINT_EXPR (clause),
1205 spc, flags, false);
1206 pp_right_paren (pp);
1207 break;
1208
1209 case OMP_CLAUSE_FILTER:
1210 pp_string (pp, "filter(");
1211 dump_generic_node (pp, OMP_CLAUSE_FILTER_EXPR (clause),
1212 spc, flags, false);
1213 pp_right_paren (pp);
1214 break;
1215
1216 case OMP_CLAUSE_DEFAULTMAP:
1217 pp_string (pp, "defaultmap(");
1218 switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (clause))
1219 {
1220 case OMP_CLAUSE_DEFAULTMAP_ALLOC:
1221 pp_string (pp, "alloc");
1222 break;
1223 case OMP_CLAUSE_DEFAULTMAP_TO:
1224 pp_string (pp, "to");
1225 break;
1226 case OMP_CLAUSE_DEFAULTMAP_FROM:
1227 pp_string (pp, "from");
1228 break;
1229 case OMP_CLAUSE_DEFAULTMAP_TOFROM:
1230 pp_string (pp, "tofrom");
1231 break;
1232 case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE:
1233 pp_string (pp, "firstprivate");
1234 break;
1235 case OMP_CLAUSE_DEFAULTMAP_NONE:
1236 pp_string (pp, "none");
1237 break;
1238 case OMP_CLAUSE_DEFAULTMAP_PRESENT:
1239 pp_string (pp, "present");
1240 break;
1241 case OMP_CLAUSE_DEFAULTMAP_DEFAULT:
1242 pp_string (pp, "default");
1243 break;
1244 default:
1245 gcc_unreachable ();
1246 }
1247 switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (clause))
1248 {
1249 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED:
1250 break;
1251 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL:
1252 pp_string (pp, ":all");
1253 break;
1254 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR:
1255 pp_string (pp, ":scalar");
1256 break;
1257 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE:
1258 pp_string (pp, ":aggregate");
1259 break;
1260 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE:
1261 pp_string (pp, ":allocatable");
1262 break;
1263 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER:
1264 pp_string (pp, ":pointer");
1265 break;
1266 default:
1267 gcc_unreachable ();
1268 }
1269 pp_right_paren (pp);
1270 break;
1271
1272 case OMP_CLAUSE_ORDER:
1273 pp_string (pp, "order(");
1274 if (OMP_CLAUSE_ORDER_UNCONSTRAINED (clause))
1275 pp_string (pp, "unconstrained:");
1276 else if (OMP_CLAUSE_ORDER_REPRODUCIBLE (clause))
1277 pp_string (pp, "reproducible:");
1278 pp_string (pp, "concurrent)");
1279 break;
1280
1281 case OMP_CLAUSE_BIND:
1282 pp_string (pp, "bind(");
1283 switch (OMP_CLAUSE_BIND_KIND (clause))
1284 {
1285 case OMP_CLAUSE_BIND_TEAMS:
1286 pp_string (pp, "teams");
1287 break;
1288 case OMP_CLAUSE_BIND_PARALLEL:
1289 pp_string (pp, "parallel");
1290 break;
1291 case OMP_CLAUSE_BIND_THREAD:
1292 pp_string (pp, "thread");
1293 break;
1294 default:
1295 gcc_unreachable ();
1296 }
1297 pp_right_paren (pp);
1298 break;
1299
1300 case OMP_CLAUSE__SIMDUID_:
1301 pp_string (pp, "_simduid_(");
1302 dump_generic_node (pp, OMP_CLAUSE__SIMDUID__DECL (clause),
1303 spc, flags, false);
1304 pp_right_paren (pp);
1305 break;
1306
1307 case OMP_CLAUSE__SIMT_:
1308 pp_string (pp, "_simt_");
1309 break;
1310
1311 case OMP_CLAUSE_GANG:
1312 pp_string (pp, "gang");
1313 if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE)
1314 {
1315 pp_string (pp, "(num: ");
1316 dump_generic_node (pp, OMP_CLAUSE_GANG_EXPR (clause),
1317 spc, flags, false);
1318 }
1319 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE)
1320 {
1321 if (OMP_CLAUSE_GANG_EXPR (clause) == NULL_TREE)
1322 pp_left_paren (pp);
1323 else
1324 pp_space (pp);
1325 pp_string (pp, "static:");
1326 if (OMP_CLAUSE_GANG_STATIC_EXPR (clause)
1327 == integer_minus_one_node)
1328 pp_character (pp, '*');
1329 else
1330 dump_generic_node (pp, OMP_CLAUSE_GANG_STATIC_EXPR (clause),
1331 spc, flags, false);
1332 }
1333 if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE
1334 || OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE)
1335 pp_right_paren (pp);
1336 break;
1337
1338 case OMP_CLAUSE_ASYNC:
1339 pp_string (pp, "async");
1340 if (OMP_CLAUSE_ASYNC_EXPR (clause))
1341 {
1342 pp_character(pp, '(');
1343 dump_generic_node (pp, OMP_CLAUSE_ASYNC_EXPR (clause),
1344 spc, flags, false);
1345 pp_character(pp, ')');
1346 }
1347 break;
1348
1349 case OMP_CLAUSE_AUTO:
1350 case OMP_CLAUSE_SEQ:
1351 pp_string (pp, omp_clause_code_name[OMP_CLAUSE_CODE (clause)]);
1352 break;
1353
1354 case OMP_CLAUSE_WAIT:
1355 pp_string (pp, "wait(");
1356 dump_generic_node (pp, OMP_CLAUSE_WAIT_EXPR (clause),
1357 spc, flags, false);
1358 pp_character(pp, ')');
1359 break;
1360
1361 case OMP_CLAUSE_WORKER:
1362 pp_string (pp, "worker");
1363 if (OMP_CLAUSE_WORKER_EXPR (clause) != NULL_TREE)
1364 {
1365 pp_left_paren (pp);
1366 dump_generic_node (pp, OMP_CLAUSE_WORKER_EXPR (clause),
1367 spc, flags, false);
1368 pp_right_paren (pp);
1369 }
1370 break;
1371
1372 case OMP_CLAUSE_VECTOR:
1373 pp_string (pp, "vector");
1374 if (OMP_CLAUSE_VECTOR_EXPR (clause) != NULL_TREE)
1375 {
1376 pp_left_paren (pp);
1377 dump_generic_node (pp, OMP_CLAUSE_VECTOR_EXPR (clause),
1378 spc, flags, false);
1379 pp_right_paren (pp);
1380 }
1381 break;
1382
1383 case OMP_CLAUSE_NUM_GANGS:
1384 pp_string (pp, "num_gangs(");
1385 dump_generic_node (pp, OMP_CLAUSE_NUM_GANGS_EXPR (clause),
1386 spc, flags, false);
1387 pp_character (pp, ')');
1388 break;
1389
1390 case OMP_CLAUSE_NUM_WORKERS:
1391 pp_string (pp, "num_workers(");
1392 dump_generic_node (pp, OMP_CLAUSE_NUM_WORKERS_EXPR (clause),
1393 spc, flags, false);
1394 pp_character (pp, ')');
1395 break;
1396
1397 case OMP_CLAUSE_VECTOR_LENGTH:
1398 pp_string (pp, "vector_length(");
1399 dump_generic_node (pp, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause),
1400 spc, flags, false);
1401 pp_character (pp, ')');
1402 break;
1403
1404 case OMP_CLAUSE_INBRANCH:
1405 pp_string (pp, "inbranch");
1406 break;
1407 case OMP_CLAUSE_NOTINBRANCH:
1408 pp_string (pp, "notinbranch");
1409 break;
1410 case OMP_CLAUSE_FOR:
1411 pp_string (pp, "for");
1412 break;
1413 case OMP_CLAUSE_PARALLEL:
1414 pp_string (pp, "parallel");
1415 break;
1416 case OMP_CLAUSE_SECTIONS:
1417 pp_string (pp, "sections");
1418 break;
1419 case OMP_CLAUSE_TASKGROUP:
1420 pp_string (pp, "taskgroup");
1421 break;
1422 case OMP_CLAUSE_NOGROUP:
1423 pp_string (pp, "nogroup");
1424 break;
1425 case OMP_CLAUSE_THREADS:
1426 pp_string (pp, "threads");
1427 break;
1428 case OMP_CLAUSE_SIMD:
1429 pp_string (pp, "simd");
1430 break;
1431 case OMP_CLAUSE_INDEPENDENT:
1432 pp_string (pp, "independent");
1433 break;
1434 case OMP_CLAUSE_TILE:
1435 pp_string (pp, "tile(");
1436 dump_generic_node (pp, OMP_CLAUSE_TILE_LIST (clause),
1437 spc, flags, false);
1438 pp_right_paren (pp);
1439 break;
1440
1441 case OMP_CLAUSE_IF_PRESENT:
1442 pp_string (pp, "if_present");
1443 break;
1444 case OMP_CLAUSE_FINALIZE:
1445 pp_string (pp, "finalize");
1446 break;
1447 case OMP_CLAUSE_NOHOST:
1448 pp_string (pp, "nohost");
1449 break;
1450 case OMP_CLAUSE_DETACH:
1451 pp_string (pp, "detach(");
1452 dump_generic_node (pp, OMP_CLAUSE_DECL (clause), spc, flags,
1453 false);
1454 pp_right_paren (pp);
1455 break;
1456
1457 default:
1458 gcc_unreachable ();
1459 }
1460 }
1461
1462
1463 /* Dump chain of OMP clauses.
1464
1465 PP, SPC and FLAGS are as in dump_generic_node. */
1466
1467 void
1468 dump_omp_clauses (pretty_printer *pp, tree clause, int spc, dump_flags_t flags,
1469 bool leading_space)
1470 {
1471 while (clause)
1472 {
1473 if (leading_space)
1474 pp_space (pp);
1475 dump_omp_clause (pp, clause, spc, flags);
1476 leading_space = true;
1477
1478 clause = OMP_CLAUSE_CHAIN (clause);
1479 }
1480 }
1481
1482
1483 /* Dump location LOC to PP. */
1484
1485 void
1486 dump_location (pretty_printer *pp, location_t loc)
1487 {
1488 expanded_location xloc = expand_location (loc);
1489 int discriminator = get_discriminator_from_loc (loc);
1490
1491 pp_left_bracket (pp);
1492 if (xloc.file)
1493 {
1494 pp_string (pp, xloc.file);
1495 pp_string (pp, ":");
1496 }
1497 pp_decimal_int (pp, xloc.line);
1498 pp_colon (pp);
1499 pp_decimal_int (pp, xloc.column);
1500 if (discriminator)
1501 {
1502 pp_string (pp, " discrim ");
1503 pp_decimal_int (pp, discriminator);
1504 }
1505 pp_string (pp, "] ");
1506 }
1507
1508
1509 /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1510 dump_generic_node. */
1511
1512 static void
1513 dump_block_node (pretty_printer *pp, tree block, int spc, dump_flags_t flags)
1514 {
1515 tree t;
1516
1517 pp_string (pp, "BLOCK #");
1518 pp_decimal_int (pp, BLOCK_NUMBER (block));
1519 pp_character (pp, ' ');
1520
1521 if (flags & TDF_ADDRESS)
1522 {
1523 pp_character (pp, '[');
1524 pp_scalar (pp, "%p", (void *) block);
1525 pp_string (pp, "] ");
1526 }
1527
1528 if (TREE_ASM_WRITTEN (block))
1529 pp_string (pp, "[written] ");
1530
1531 if (flags & TDF_SLIM)
1532 return;
1533
1534 if (BLOCK_SOURCE_LOCATION (block))
1535 dump_location (pp, BLOCK_SOURCE_LOCATION (block));
1536
1537 newline_and_indent (pp, spc + 2);
1538
1539 if (BLOCK_SUPERCONTEXT (block))
1540 {
1541 pp_string (pp, "SUPERCONTEXT: ");
1542 dump_generic_node (pp, BLOCK_SUPERCONTEXT (block), 0,
1543 flags | TDF_SLIM, false);
1544 newline_and_indent (pp, spc + 2);
1545 }
1546
1547 if (BLOCK_SUBBLOCKS (block))
1548 {
1549 pp_string (pp, "SUBBLOCKS: ");
1550 for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
1551 {
1552 dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
1553 pp_space (pp);
1554 }
1555 newline_and_indent (pp, spc + 2);
1556 }
1557
1558 if (BLOCK_CHAIN (block))
1559 {
1560 pp_string (pp, "SIBLINGS: ");
1561 for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))
1562 {
1563 dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
1564 pp_space (pp);
1565 }
1566 newline_and_indent (pp, spc + 2);
1567 }
1568
1569 if (BLOCK_VARS (block))
1570 {
1571 pp_string (pp, "VARS: ");
1572 for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
1573 {
1574 dump_generic_node (pp, t, 0, flags, false);
1575 pp_space (pp);
1576 }
1577 newline_and_indent (pp, spc + 2);
1578 }
1579
1580 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block)) > 0)
1581 {
1582 unsigned i;
1583 vec<tree, va_gc> *nlv = BLOCK_NONLOCALIZED_VARS (block);
1584
1585 pp_string (pp, "NONLOCALIZED_VARS: ");
1586 FOR_EACH_VEC_ELT (*nlv, i, t)
1587 {
1588 dump_generic_node (pp, t, 0, flags, false);
1589 pp_space (pp);
1590 }
1591 newline_and_indent (pp, spc + 2);
1592 }
1593
1594 if (BLOCK_ABSTRACT_ORIGIN (block))
1595 {
1596 pp_string (pp, "ABSTRACT_ORIGIN: ");
1597 dump_generic_node (pp, BLOCK_ABSTRACT_ORIGIN (block), 0,
1598 flags | TDF_SLIM, false);
1599 newline_and_indent (pp, spc + 2);
1600 }
1601
1602 if (BLOCK_FRAGMENT_ORIGIN (block))
1603 {
1604 pp_string (pp, "FRAGMENT_ORIGIN: ");
1605 dump_generic_node (pp, BLOCK_FRAGMENT_ORIGIN (block), 0,
1606 flags | TDF_SLIM, false);
1607 newline_and_indent (pp, spc + 2);
1608 }
1609
1610 if (BLOCK_FRAGMENT_CHAIN (block))
1611 {
1612 pp_string (pp, "FRAGMENT_CHAIN: ");
1613 for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))
1614 {
1615 dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
1616 pp_space (pp);
1617 }
1618 newline_and_indent (pp, spc + 2);
1619 }
1620 }
1621
1622 /* Dump #pragma omp atomic memory order clause. */
1623
1624 void
1625 dump_omp_atomic_memory_order (pretty_printer *pp, enum omp_memory_order mo)
1626 {
1627 switch (mo & OMP_MEMORY_ORDER_MASK)
1628 {
1629 case OMP_MEMORY_ORDER_RELAXED:
1630 pp_string (pp, " relaxed");
1631 break;
1632 case OMP_MEMORY_ORDER_SEQ_CST:
1633 pp_string (pp, " seq_cst");
1634 break;
1635 case OMP_MEMORY_ORDER_ACQ_REL:
1636 pp_string (pp, " acq_rel");
1637 break;
1638 case OMP_MEMORY_ORDER_ACQUIRE:
1639 pp_string (pp, " acquire");
1640 break;
1641 case OMP_MEMORY_ORDER_RELEASE:
1642 pp_string (pp, " release");
1643 break;
1644 case OMP_MEMORY_ORDER_UNSPECIFIED:
1645 break;
1646 default:
1647 gcc_unreachable ();
1648 }
1649 switch (mo & OMP_FAIL_MEMORY_ORDER_MASK)
1650 {
1651 case OMP_FAIL_MEMORY_ORDER_RELAXED:
1652 pp_string (pp, " fail(relaxed)");
1653 break;
1654 case OMP_FAIL_MEMORY_ORDER_SEQ_CST:
1655 pp_string (pp, " fail(seq_cst)");
1656 break;
1657 case OMP_FAIL_MEMORY_ORDER_ACQUIRE:
1658 pp_string (pp, " fail(acquire)");
1659 break;
1660 case OMP_FAIL_MEMORY_ORDER_UNSPECIFIED:
1661 break;
1662 default:
1663 gcc_unreachable ();
1664 }
1665 }
1666
1667 /* Helper to dump a MEM_REF node. */
1668
1669 static void
1670 dump_mem_ref (pretty_printer *pp, tree node, int spc, dump_flags_t flags)
1671 {
1672 if (TREE_CODE (node) == MEM_REF && (flags & TDF_GIMPLE))
1673 {
1674 pp_string (pp, "__MEM <");
1675 dump_generic_node (pp, TREE_TYPE (node),
1676 spc, flags | TDF_SLIM, false);
1677 if (TYPE_ALIGN (TREE_TYPE (node))
1678 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
1679 {
1680 pp_string (pp, ", ");
1681 pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
1682 }
1683 pp_greater (pp);
1684 pp_string (pp, " (");
1685 if (TREE_TYPE (TREE_OPERAND (node, 0))
1686 != TREE_TYPE (TREE_OPERAND (node, 1)))
1687 {
1688 pp_left_paren (pp);
1689 dump_generic_node (pp, TREE_TYPE (TREE_OPERAND (node, 1)),
1690 spc, flags | TDF_SLIM, false);
1691 pp_right_paren (pp);
1692 }
1693 dump_generic_node (pp, TREE_OPERAND (node, 0),
1694 spc, flags | TDF_SLIM, false);
1695 if (! integer_zerop (TREE_OPERAND (node, 1)))
1696 {
1697 pp_string (pp, " + ");
1698 dump_generic_node (pp, TREE_OPERAND (node, 1),
1699 spc, flags | TDF_SLIM, false);
1700 }
1701 pp_right_paren (pp);
1702 }
1703 else if (TREE_CODE (node) == MEM_REF
1704 && integer_zerop (TREE_OPERAND (node, 1))
1705 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1706 infer them and MEM_ATTR caching will share MEM_REFs
1707 with differently-typed op0s. */
1708 && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
1709 /* Released SSA_NAMES have no TREE_TYPE. */
1710 && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
1711 /* Same pointer types, but ignoring POINTER_TYPE vs.
1712 REFERENCE_TYPE. */
1713 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
1714 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
1715 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
1716 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
1717 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
1718 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
1719 /* Same value types ignoring qualifiers. */
1720 && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
1721 == TYPE_MAIN_VARIANT
1722 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))
1723 && (!(flags & TDF_ALIAS)
1724 || MR_DEPENDENCE_CLIQUE (node) == 0))
1725 {
1726 if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
1727 {
1728 /* Enclose pointers to arrays in parentheses. */
1729 tree op0 = TREE_OPERAND (node, 0);
1730 tree op0type = TREE_TYPE (op0);
1731 if (POINTER_TYPE_P (op0type)
1732 && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
1733 pp_left_paren (pp);
1734 pp_star (pp);
1735 dump_generic_node (pp, op0, spc, flags, false);
1736 if (POINTER_TYPE_P (op0type)
1737 && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
1738 pp_right_paren (pp);
1739 }
1740 else
1741 dump_generic_node (pp,
1742 TREE_OPERAND (TREE_OPERAND (node, 0), 0),
1743 spc, flags, false);
1744 }
1745 else
1746 {
1747 pp_string (pp, "MEM");
1748
1749 tree nodetype = TREE_TYPE (node);
1750 tree op0 = TREE_OPERAND (node, 0);
1751 tree op1 = TREE_OPERAND (node, 1);
1752 tree op1type = TYPE_MAIN_VARIANT (TREE_TYPE (op1));
1753
1754 tree op0size = TYPE_SIZE (nodetype);
1755 tree op1size = TYPE_SIZE (TREE_TYPE (op1type));
1756
1757 if (!op0size || !op1size
1758 || !operand_equal_p (op0size, op1size, 0))
1759 {
1760 pp_string (pp, " <");
1761 /* If the size of the type of the operand is not the same
1762 as the size of the MEM_REF expression include the type
1763 of the latter similar to the TDF_GIMPLE output to make
1764 it clear how many bytes of memory are being accessed. */
1765 dump_generic_node (pp, nodetype, spc, flags | TDF_SLIM, false);
1766 pp_string (pp, "> ");
1767 }
1768
1769 pp_string (pp, "[(");
1770 dump_generic_node (pp, op1type, spc, flags | TDF_SLIM, false);
1771 pp_right_paren (pp);
1772 dump_generic_node (pp, op0, spc, flags, false);
1773 if (!integer_zerop (op1))
1774 {
1775 pp_string (pp, " + ");
1776 dump_generic_node (pp, op1, spc, flags, false);
1777 }
1778 if (TREE_CODE (node) == TARGET_MEM_REF)
1779 {
1780 tree tmp = TMR_INDEX2 (node);
1781 if (tmp)
1782 {
1783 pp_string (pp, " + ");
1784 dump_generic_node (pp, tmp, spc, flags, false);
1785 }
1786 tmp = TMR_INDEX (node);
1787 if (tmp)
1788 {
1789 pp_string (pp, " + ");
1790 dump_generic_node (pp, tmp, spc, flags, false);
1791 tmp = TMR_STEP (node);
1792 pp_string (pp, " * ");
1793 if (tmp)
1794 dump_generic_node (pp, tmp, spc, flags, false);
1795 else
1796 pp_string (pp, "1");
1797 }
1798 }
1799 if ((flags & TDF_ALIAS)
1800 && MR_DEPENDENCE_CLIQUE (node) != 0)
1801 {
1802 pp_string (pp, " clique ");
1803 pp_unsigned_wide_integer (pp, MR_DEPENDENCE_CLIQUE (node));
1804 pp_string (pp, " base ");
1805 pp_unsigned_wide_integer (pp, MR_DEPENDENCE_BASE (node));
1806 }
1807 pp_right_bracket (pp);
1808 }
1809 }
1810
1811 /* Helper function for dump_generic_node. Dump INIT or COND expression for
1812 OpenMP loop non-rectangular iterators. */
1813
1814 void
1815 dump_omp_loop_non_rect_expr (pretty_printer *pp, tree node, int spc,
1816 dump_flags_t flags)
1817 {
1818 gcc_assert (TREE_CODE (node) == TREE_VEC);
1819 dump_generic_node (pp, TREE_VEC_ELT (node, 0), spc, flags, false);
1820 pp_string (pp, " * ");
1821 if (op_prio (TREE_VEC_ELT (node, 1)) <= op_code_prio (MULT_EXPR))
1822 {
1823 pp_left_paren (pp);
1824 dump_generic_node (pp, TREE_VEC_ELT (node, 1), spc, flags, false);
1825 pp_right_paren (pp);
1826 }
1827 else
1828 dump_generic_node (pp, TREE_VEC_ELT (node, 1), spc, flags, false);
1829 pp_string (pp, " + ");
1830 if (op_prio (TREE_VEC_ELT (node, 1)) <= op_code_prio (PLUS_EXPR))
1831 {
1832 pp_left_paren (pp);
1833 dump_generic_node (pp, TREE_VEC_ELT (node, 2), spc, flags, false);
1834 pp_right_paren (pp);
1835 }
1836 else
1837 dump_generic_node (pp, TREE_VEC_ELT (node, 2), spc, flags, false);
1838 }
1839
1840 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1841 indent. FLAGS specifies details to show in the dump (see TDF_* in
1842 dumpfile.h). If IS_STMT is true, the object printed is considered
1843 to be a statement and it is terminated by ';' if appropriate. */
1844
1845 int
1846 dump_generic_node (pretty_printer *pp, tree node, int spc, dump_flags_t flags,
1847 bool is_stmt)
1848 {
1849 tree type;
1850 tree op0, op1;
1851 const char *str;
1852 bool is_expr;
1853 enum tree_code code;
1854
1855 if (node == NULL_TREE)
1856 return spc;
1857
1858 is_expr = EXPR_P (node);
1859
1860 if (is_stmt && (flags & TDF_STMTADDR))
1861 {
1862 pp_string (pp, "<&");
1863 pp_scalar (pp, "%p", (void *)node);
1864 pp_string (pp, "> ");
1865 }
1866
1867 if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
1868 dump_location (pp, EXPR_LOCATION (node));
1869
1870 code = TREE_CODE (node);
1871 switch (code)
1872 {
1873 case ERROR_MARK:
1874 pp_string (pp, "<<< error >>>");
1875 break;
1876
1877 case IDENTIFIER_NODE:
1878 pp_tree_identifier (pp, node);
1879 break;
1880
1881 case TREE_LIST:
1882 while (node && node != error_mark_node)
1883 {
1884 if (TREE_PURPOSE (node))
1885 {
1886 dump_generic_node (pp, TREE_PURPOSE (node), spc, flags, false);
1887 pp_space (pp);
1888 }
1889 dump_generic_node (pp, TREE_VALUE (node), spc, flags, false);
1890 node = TREE_CHAIN (node);
1891 if (node && TREE_CODE (node) == TREE_LIST)
1892 {
1893 pp_comma (pp);
1894 pp_space (pp);
1895 }
1896 }
1897 break;
1898
1899 case TREE_BINFO:
1900 dump_generic_node (pp, BINFO_TYPE (node), spc, flags, false);
1901 break;
1902
1903 case TREE_VEC:
1904 {
1905 size_t i;
1906 pp_left_brace (pp);
1907 if (TREE_VEC_LENGTH (node) > 0)
1908 {
1909 size_t len = TREE_VEC_LENGTH (node);
1910 for (i = 0; i < len - 1; i++)
1911 {
1912 dump_generic_node (pp, TREE_VEC_ELT (node, i), spc, flags,
1913 false);
1914 pp_comma (pp);
1915 pp_space (pp);
1916 }
1917 dump_generic_node (pp, TREE_VEC_ELT (node, len - 1), spc,
1918 flags, false);
1919 }
1920 pp_right_brace (pp);
1921 }
1922 break;
1923
1924 case VOID_TYPE:
1925 case INTEGER_TYPE:
1926 case REAL_TYPE:
1927 case FIXED_POINT_TYPE:
1928 case COMPLEX_TYPE:
1929 case VECTOR_TYPE:
1930 case ENUMERAL_TYPE:
1931 case BOOLEAN_TYPE:
1932 case OPAQUE_TYPE:
1933 {
1934 unsigned int quals = TYPE_QUALS (node);
1935 enum tree_code_class tclass;
1936
1937 if (quals & TYPE_QUAL_ATOMIC)
1938 pp_string (pp, "atomic ");
1939 if (quals & TYPE_QUAL_CONST)
1940 pp_string (pp, "const ");
1941 if (quals & TYPE_QUAL_VOLATILE)
1942 pp_string (pp, "volatile ");
1943 if (quals & TYPE_QUAL_RESTRICT)
1944 pp_string (pp, "restrict ");
1945
1946 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
1947 {
1948 pp_string (pp, "<address-space-");
1949 pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
1950 pp_string (pp, "> ");
1951 }
1952
1953 tclass = TREE_CODE_CLASS (TREE_CODE (node));
1954
1955 if (tclass == tcc_declaration)
1956 {
1957 if (DECL_NAME (node))
1958 dump_decl_name (pp, node, flags);
1959 else
1960 pp_string (pp, "<unnamed type decl>");
1961 }
1962 else if (tclass == tcc_type)
1963 {
1964 if (TYPE_NAME (node))
1965 {
1966 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
1967 pp_tree_identifier (pp, TYPE_NAME (node));
1968 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
1969 && DECL_NAME (TYPE_NAME (node)))
1970 dump_decl_name (pp, TYPE_NAME (node), flags);
1971 else
1972 pp_string (pp, "<unnamed type>");
1973 }
1974 else if (TREE_CODE (node) == VECTOR_TYPE)
1975 {
1976 pp_string (pp, "vector");
1977 pp_left_paren (pp);
1978 pp_wide_integer (pp, TYPE_VECTOR_SUBPARTS (node));
1979 pp_string (pp, ") ");
1980 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1981 }
1982 else if (TREE_CODE (node) == INTEGER_TYPE)
1983 {
1984 if (TYPE_PRECISION (node) == CHAR_TYPE_SIZE)
1985 pp_string (pp, (TYPE_UNSIGNED (node)
1986 ? "unsigned char"
1987 : "signed char"));
1988 else if (TYPE_PRECISION (node) == SHORT_TYPE_SIZE)
1989 pp_string (pp, (TYPE_UNSIGNED (node)
1990 ? "unsigned short"
1991 : "signed short"));
1992 else if (TYPE_PRECISION (node) == INT_TYPE_SIZE)
1993 pp_string (pp, (TYPE_UNSIGNED (node)
1994 ? "unsigned int"
1995 : "signed int"));
1996 else if (TYPE_PRECISION (node) == LONG_TYPE_SIZE)
1997 pp_string (pp, (TYPE_UNSIGNED (node)
1998 ? "unsigned long"
1999 : "signed long"));
2000 else if (TYPE_PRECISION (node) == LONG_LONG_TYPE_SIZE)
2001 pp_string (pp, (TYPE_UNSIGNED (node)
2002 ? "unsigned long long"
2003 : "signed long long"));
2004 else if (TYPE_PRECISION (node) >= CHAR_TYPE_SIZE
2005 && pow2p_hwi (TYPE_PRECISION (node)))
2006 {
2007 pp_string (pp, (TYPE_UNSIGNED (node) ? "uint" : "int"));
2008 pp_decimal_int (pp, TYPE_PRECISION (node));
2009 pp_string (pp, "_t");
2010 }
2011 else
2012 {
2013 pp_string (pp, (TYPE_UNSIGNED (node)
2014 ? "<unnamed-unsigned:"
2015 : "<unnamed-signed:"));
2016 pp_decimal_int (pp, TYPE_PRECISION (node));
2017 pp_greater (pp);
2018 }
2019 }
2020 else if (TREE_CODE (node) == COMPLEX_TYPE)
2021 {
2022 pp_string (pp, "__complex__ ");
2023 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2024 }
2025 else if (TREE_CODE (node) == REAL_TYPE)
2026 {
2027 pp_string (pp, "<float:");
2028 pp_decimal_int (pp, TYPE_PRECISION (node));
2029 pp_greater (pp);
2030 }
2031 else if (TREE_CODE (node) == FIXED_POINT_TYPE)
2032 {
2033 pp_string (pp, "<fixed-point-");
2034 pp_string (pp, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
2035 pp_decimal_int (pp, TYPE_PRECISION (node));
2036 pp_greater (pp);
2037 }
2038 else if (TREE_CODE (node) == BOOLEAN_TYPE)
2039 {
2040 pp_string (pp, (TYPE_UNSIGNED (node)
2041 ? "<unsigned-boolean:"
2042 : "<signed-boolean:"));
2043 pp_decimal_int (pp, TYPE_PRECISION (node));
2044 pp_greater (pp);
2045 }
2046 else if (TREE_CODE (node) == VOID_TYPE)
2047 pp_string (pp, "void");
2048 else
2049 pp_string (pp, "<unnamed type>");
2050 }
2051 break;
2052 }
2053
2054 case POINTER_TYPE:
2055 case REFERENCE_TYPE:
2056 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
2057
2058 if (TREE_TYPE (node) == NULL)
2059 {
2060 pp_string (pp, str);
2061 pp_string (pp, "<null type>");
2062 }
2063 else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
2064 {
2065 tree fnode = TREE_TYPE (node);
2066
2067 dump_generic_node (pp, TREE_TYPE (fnode), spc, flags, false);
2068 pp_space (pp);
2069 pp_left_paren (pp);
2070 pp_string (pp, str);
2071 if (TYPE_IDENTIFIER (node))
2072 dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
2073 else if (flags & TDF_NOUID)
2074 pp_string (pp, "<Txxxx>");
2075 else
2076 {
2077 pp_string (pp, "<T");
2078 pp_scalar (pp, "%x", TYPE_UID (node));
2079 pp_character (pp, '>');
2080 }
2081
2082 pp_right_paren (pp);
2083 dump_function_declaration (pp, fnode, spc, flags);
2084 }
2085 else
2086 {
2087 unsigned int quals = TYPE_QUALS (node);
2088
2089 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2090 pp_space (pp);
2091 pp_string (pp, str);
2092
2093 if (quals & TYPE_QUAL_CONST)
2094 pp_string (pp, " const");
2095 if (quals & TYPE_QUAL_VOLATILE)
2096 pp_string (pp, " volatile");
2097 if (quals & TYPE_QUAL_RESTRICT)
2098 pp_string (pp, " restrict");
2099
2100 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
2101 {
2102 pp_string (pp, " <address-space-");
2103 pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
2104 pp_greater (pp);
2105 }
2106
2107 if (TYPE_REF_CAN_ALIAS_ALL (node))
2108 pp_string (pp, " {ref-all}");
2109 }
2110 break;
2111
2112 case OFFSET_TYPE:
2113 NIY;
2114 break;
2115
2116 case MEM_REF:
2117 case TARGET_MEM_REF:
2118 dump_mem_ref (pp, node, spc, flags);
2119 break;
2120
2121 case ARRAY_TYPE:
2122 {
2123 unsigned int quals = TYPE_QUALS (node);
2124 tree tmp;
2125
2126 if (quals & TYPE_QUAL_ATOMIC)
2127 pp_string (pp, "atomic ");
2128 if (quals & TYPE_QUAL_CONST)
2129 pp_string (pp, "const ");
2130 if (quals & TYPE_QUAL_VOLATILE)
2131 pp_string (pp, "volatile ");
2132
2133 /* Print the innermost component type. */
2134 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
2135 tmp = TREE_TYPE (tmp))
2136 ;
2137
2138 /* Avoid to print recursively the array. */
2139 /* FIXME : Not implemented correctly, see print_struct_decl. */
2140 if (TREE_CODE (tmp) != POINTER_TYPE || TREE_TYPE (tmp) != node)
2141 dump_generic_node (pp, tmp, spc, flags, false);
2142
2143 /* Print the dimensions. */
2144 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
2145 dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
2146 break;
2147 }
2148
2149 case RECORD_TYPE:
2150 case UNION_TYPE:
2151 case QUAL_UNION_TYPE:
2152 {
2153 unsigned int quals = TYPE_QUALS (node);
2154
2155 if (quals & TYPE_QUAL_ATOMIC)
2156 pp_string (pp, "atomic ");
2157 if (quals & TYPE_QUAL_CONST)
2158 pp_string (pp, "const ");
2159 if (quals & TYPE_QUAL_VOLATILE)
2160 pp_string (pp, "volatile ");
2161
2162 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
2163 {
2164 pp_string (pp, "<address-space-");
2165 pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
2166 pp_string (pp, "> ");
2167 }
2168
2169 /* Print the name of the structure. */
2170 if (TREE_CODE (node) == RECORD_TYPE)
2171 pp_string (pp, "struct ");
2172 else if (TREE_CODE (node) == UNION_TYPE)
2173 pp_string (pp, "union ");
2174
2175 if (TYPE_NAME (node))
2176 dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
2177 else if (!(flags & TDF_SLIM))
2178 /* FIXME: If we eliminate the 'else' above and attempt
2179 to show the fields for named types, we may get stuck
2180 following a cycle of pointers to structs. The alleged
2181 self-reference check in print_struct_decl will not detect
2182 cycles involving more than one pointer or struct type. */
2183 print_struct_decl (pp, node, spc, flags);
2184 break;
2185 }
2186
2187 case LANG_TYPE:
2188 NIY;
2189 break;
2190
2191 case INTEGER_CST:
2192 if (flags & TDF_GIMPLE
2193 && (POINTER_TYPE_P (TREE_TYPE (node))
2194 || (TYPE_PRECISION (TREE_TYPE (node))
2195 < TYPE_PRECISION (integer_type_node))
2196 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1
2197 || tree_int_cst_sgn (node) < 0))
2198 {
2199 pp_string (pp, "_Literal (");
2200 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2201 pp_string (pp, ") ");
2202 }
2203 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE
2204 && ! (flags & TDF_GIMPLE))
2205 {
2206 /* In the case of a pointer, one may want to divide by the
2207 size of the pointed-to type. Unfortunately, this not
2208 straightforward. The C front-end maps expressions
2209
2210 (int *) 5
2211 int *p; (p + 5)
2212
2213 in such a way that the two INTEGER_CST nodes for "5" have
2214 different values but identical types. In the latter
2215 case, the 5 is multiplied by sizeof (int) in c-common.cc
2216 (pointer_int_sum) to convert it to a byte address, and
2217 yet the type of the node is left unchanged. Argh. What
2218 is consistent though is that the number value corresponds
2219 to bytes (UNITS) offset.
2220
2221 NB: Neither of the following divisors can be trivially
2222 used to recover the original literal:
2223
2224 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
2225 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
2226 pp_wide_integer (pp, TREE_INT_CST_LOW (node));
2227 pp_string (pp, "B"); /* pseudo-unit */
2228 }
2229 else if (tree_fits_shwi_p (node))
2230 pp_wide_integer (pp, tree_to_shwi (node));
2231 else if (tree_fits_uhwi_p (node))
2232 pp_unsigned_wide_integer (pp, tree_to_uhwi (node));
2233 else
2234 {
2235 wide_int val = wi::to_wide (node);
2236
2237 if (wi::neg_p (val, TYPE_SIGN (TREE_TYPE (node))))
2238 {
2239 pp_minus (pp);
2240 val = -val;
2241 }
2242 print_hex (val, pp_buffer (pp)->digit_buffer);
2243 pp_string (pp, pp_buffer (pp)->digit_buffer);
2244 }
2245 if ((flags & TDF_GIMPLE)
2246 && ! (POINTER_TYPE_P (TREE_TYPE (node))
2247 || (TYPE_PRECISION (TREE_TYPE (node))
2248 < TYPE_PRECISION (integer_type_node))
2249 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1))
2250 {
2251 if (TYPE_UNSIGNED (TREE_TYPE (node)))
2252 pp_character (pp, 'u');
2253 if (TYPE_PRECISION (TREE_TYPE (node))
2254 == TYPE_PRECISION (unsigned_type_node))
2255 ;
2256 else if (TYPE_PRECISION (TREE_TYPE (node))
2257 == TYPE_PRECISION (long_unsigned_type_node))
2258 pp_character (pp, 'l');
2259 else if (TYPE_PRECISION (TREE_TYPE (node))
2260 == TYPE_PRECISION (long_long_unsigned_type_node))
2261 pp_string (pp, "ll");
2262 }
2263 if (TREE_OVERFLOW (node))
2264 pp_string (pp, "(OVF)");
2265 break;
2266
2267 case POLY_INT_CST:
2268 pp_string (pp, "POLY_INT_CST [");
2269 dump_generic_node (pp, POLY_INT_CST_COEFF (node, 0), spc, flags, false);
2270 for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
2271 {
2272 pp_string (pp, ", ");
2273 dump_generic_node (pp, POLY_INT_CST_COEFF (node, i),
2274 spc, flags, false);
2275 }
2276 pp_string (pp, "]");
2277 break;
2278
2279 case REAL_CST:
2280 /* Code copied from print_node. */
2281 {
2282 REAL_VALUE_TYPE d;
2283 if (TREE_OVERFLOW (node))
2284 pp_string (pp, " overflow");
2285
2286 d = TREE_REAL_CST (node);
2287 if (REAL_VALUE_ISINF (d))
2288 pp_string (pp, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
2289 else if (REAL_VALUE_ISNAN (d))
2290 pp_string (pp, " Nan");
2291 else
2292 {
2293 char string[100];
2294 real_to_decimal (string, &d, sizeof (string), 0, 1);
2295 pp_string (pp, string);
2296 }
2297 break;
2298 }
2299
2300 case FIXED_CST:
2301 {
2302 char string[100];
2303 fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
2304 pp_string (pp, string);
2305 break;
2306 }
2307
2308 case COMPLEX_CST:
2309 pp_string (pp, "__complex__ (");
2310 dump_generic_node (pp, TREE_REALPART (node), spc, flags, false);
2311 pp_string (pp, ", ");
2312 dump_generic_node (pp, TREE_IMAGPART (node), spc, flags, false);
2313 pp_right_paren (pp);
2314 break;
2315
2316 case STRING_CST:
2317 {
2318 pp_string (pp, "\"");
2319 if (unsigned nbytes = TREE_STRING_LENGTH (node))
2320 pretty_print_string (pp, TREE_STRING_POINTER (node), nbytes);
2321 pp_string (pp, "\"");
2322 break;
2323 }
2324
2325 case VECTOR_CST:
2326 {
2327 unsigned i;
2328 if (flags & TDF_GIMPLE)
2329 {
2330 pp_string (pp, "_Literal (");
2331 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2332 pp_string (pp, ") ");
2333 }
2334 pp_string (pp, "{ ");
2335 unsigned HOST_WIDE_INT nunits;
2336 if (!VECTOR_CST_NELTS (node).is_constant (&nunits))
2337 nunits = vector_cst_encoded_nelts (node);
2338 for (i = 0; i < nunits; ++i)
2339 {
2340 if (i != 0)
2341 pp_string (pp, ", ");
2342 dump_generic_node (pp, VECTOR_CST_ELT (node, i),
2343 spc, flags, false);
2344 }
2345 if (!VECTOR_CST_NELTS (node).is_constant ())
2346 pp_string (pp, ", ...");
2347 pp_string (pp, " }");
2348 }
2349 break;
2350
2351 case FUNCTION_TYPE:
2352 case METHOD_TYPE:
2353 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2354 pp_space (pp);
2355 if (TREE_CODE (node) == METHOD_TYPE)
2356 {
2357 if (TYPE_METHOD_BASETYPE (node))
2358 dump_generic_node (pp, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
2359 spc, flags, false);
2360 else
2361 pp_string (pp, "<null method basetype>");
2362 pp_colon_colon (pp);
2363 }
2364 if (TYPE_IDENTIFIER (node))
2365 dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
2366 else if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
2367 dump_decl_name (pp, TYPE_NAME (node), flags);
2368 else if (flags & TDF_NOUID)
2369 pp_string (pp, "<Txxxx>");
2370 else
2371 {
2372 pp_string (pp, "<T");
2373 pp_scalar (pp, "%x", TYPE_UID (node));
2374 pp_character (pp, '>');
2375 }
2376 dump_function_declaration (pp, node, spc, flags);
2377 break;
2378
2379 case FUNCTION_DECL:
2380 case CONST_DECL:
2381 dump_decl_name (pp, node, flags);
2382 break;
2383
2384 case LABEL_DECL:
2385 if (DECL_NAME (node))
2386 dump_decl_name (pp, node, flags);
2387 else if (LABEL_DECL_UID (node) != -1)
2388 {
2389 if (flags & TDF_GIMPLE)
2390 {
2391 pp_character (pp, 'L');
2392 pp_decimal_int (pp, (int) LABEL_DECL_UID (node));
2393 }
2394 else
2395 {
2396 pp_string (pp, "<L");
2397 pp_decimal_int (pp, (int) LABEL_DECL_UID (node));
2398 pp_character (pp, '>');
2399 }
2400 }
2401 else
2402 {
2403 if (flags & TDF_NOUID)
2404 pp_string (pp, "<D.xxxx>");
2405 else
2406 {
2407 if (flags & TDF_GIMPLE)
2408 {
2409 pp_character (pp, 'D');
2410 pp_scalar (pp, "%u", DECL_UID (node));
2411 }
2412 else
2413 {
2414 pp_string (pp, "<D.");
2415 pp_scalar (pp, "%u", DECL_UID (node));
2416 pp_character (pp, '>');
2417 }
2418 }
2419 }
2420 break;
2421
2422 case TYPE_DECL:
2423 if (DECL_IS_UNDECLARED_BUILTIN (node))
2424 {
2425 /* Don't print the declaration of built-in types. */
2426 break;
2427 }
2428 if (DECL_NAME (node))
2429 dump_decl_name (pp, node, flags);
2430 else if (TYPE_NAME (TREE_TYPE (node)) != node)
2431 {
2432 pp_string (pp, (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
2433 ? "union" : "struct "));
2434 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2435 }
2436 else
2437 pp_string (pp, "<anon>");
2438 break;
2439
2440 case VAR_DECL:
2441 case PARM_DECL:
2442 case FIELD_DECL:
2443 case DEBUG_EXPR_DECL:
2444 case NAMESPACE_DECL:
2445 case NAMELIST_DECL:
2446 dump_decl_name (pp, node, flags);
2447 break;
2448
2449 case RESULT_DECL:
2450 pp_string (pp, "<retval>");
2451 break;
2452
2453 case COMPONENT_REF:
2454 op0 = TREE_OPERAND (node, 0);
2455 str = ".";
2456 if (op0
2457 && (TREE_CODE (op0) == INDIRECT_REF
2458 || (TREE_CODE (op0) == MEM_REF
2459 && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR
2460 && integer_zerop (TREE_OPERAND (op0, 1))
2461 /* Dump the types of INTEGER_CSTs explicitly, for we
2462 can't infer them and MEM_ATTR caching will share
2463 MEM_REFs with differently-typed op0s. */
2464 && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST
2465 /* Released SSA_NAMES have no TREE_TYPE. */
2466 && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE
2467 /* Same pointer types, but ignoring POINTER_TYPE vs.
2468 REFERENCE_TYPE. */
2469 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
2470 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))
2471 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0)))
2472 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1))))
2473 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0)))
2474 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1))))
2475 /* Same value types ignoring qualifiers. */
2476 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0))
2477 == TYPE_MAIN_VARIANT
2478 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))))
2479 && MR_DEPENDENCE_CLIQUE (op0) == 0)))
2480 {
2481 op0 = TREE_OPERAND (op0, 0);
2482 str = "->";
2483 }
2484 if (op_prio (op0) < op_prio (node))
2485 pp_left_paren (pp);
2486 dump_generic_node (pp, op0, spc, flags, false);
2487 if (op_prio (op0) < op_prio (node))
2488 pp_right_paren (pp);
2489 pp_string (pp, str);
2490 op1 = TREE_OPERAND (node, 1);
2491 dump_generic_node (pp, op1, spc, flags, false);
2492 if (DECL_P (op1)) /* Not always a decl in the C++ FE. */
2493 if (tree off = component_ref_field_offset (node))
2494 if (TREE_CODE (off) != INTEGER_CST)
2495 {
2496 pp_string (pp, "{off: ");
2497 dump_generic_node (pp, off, spc, flags, false);
2498 pp_right_brace (pp);
2499 }
2500 break;
2501
2502 case BIT_FIELD_REF:
2503 if (flags & TDF_GIMPLE)
2504 {
2505 pp_string (pp, "__BIT_FIELD_REF <");
2506 dump_generic_node (pp, TREE_TYPE (node),
2507 spc, flags | TDF_SLIM, false);
2508 if (TYPE_ALIGN (TREE_TYPE (node))
2509 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
2510 {
2511 pp_string (pp, ", ");
2512 pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
2513 }
2514 pp_greater (pp);
2515 pp_string (pp, " (");
2516 dump_generic_node (pp, TREE_OPERAND (node, 0), spc,
2517 flags | TDF_SLIM, false);
2518 pp_string (pp, ", ");
2519 dump_generic_node (pp, TREE_OPERAND (node, 1), spc,
2520 flags | TDF_SLIM, false);
2521 pp_string (pp, ", ");
2522 dump_generic_node (pp, TREE_OPERAND (node, 2), spc,
2523 flags | TDF_SLIM, false);
2524 pp_right_paren (pp);
2525 }
2526 else
2527 {
2528 pp_string (pp, "BIT_FIELD_REF <");
2529 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2530 pp_string (pp, ", ");
2531 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2532 pp_string (pp, ", ");
2533 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2534 pp_greater (pp);
2535 }
2536 break;
2537
2538 case BIT_INSERT_EXPR:
2539 pp_string (pp, "BIT_INSERT_EXPR <");
2540 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2541 pp_string (pp, ", ");
2542 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2543 pp_string (pp, ", ");
2544 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2545 pp_string (pp, " (");
2546 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node, 1))))
2547 pp_decimal_int (pp,
2548 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node, 1))));
2549 else
2550 dump_generic_node (pp, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node, 1))),
2551 spc, flags, false);
2552 pp_string (pp, " bits)>");
2553 break;
2554
2555 case ARRAY_REF:
2556 case ARRAY_RANGE_REF:
2557 op0 = TREE_OPERAND (node, 0);
2558 if (op_prio (op0) < op_prio (node))
2559 pp_left_paren (pp);
2560 dump_generic_node (pp, op0, spc, flags, false);
2561 if (op_prio (op0) < op_prio (node))
2562 pp_right_paren (pp);
2563 pp_left_bracket (pp);
2564 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2565 if (TREE_CODE (node) == ARRAY_RANGE_REF)
2566 pp_string (pp, " ...");
2567 pp_right_bracket (pp);
2568
2569 op0 = array_ref_low_bound (node);
2570 op1 = array_ref_element_size (node);
2571
2572 if (!integer_zerop (op0)
2573 || TREE_OPERAND (node, 2)
2574 || TREE_OPERAND (node, 3))
2575 {
2576 pp_string (pp, "{lb: ");
2577 dump_generic_node (pp, op0, spc, flags, false);
2578 pp_string (pp, " sz: ");
2579 dump_generic_node (pp, op1, spc, flags, false);
2580 pp_right_brace (pp);
2581 }
2582 break;
2583
2584 case CONSTRUCTOR:
2585 {
2586 unsigned HOST_WIDE_INT ix;
2587 tree field, val;
2588 bool is_struct_init = false;
2589 bool is_array_init = false;
2590 widest_int curidx;
2591 if (flags & TDF_GIMPLE)
2592 {
2593 pp_string (pp, "_Literal (");
2594 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2595 pp_string (pp, ") ");
2596 }
2597 pp_left_brace (pp);
2598 if (TREE_CLOBBER_P (node))
2599 {
2600 pp_string (pp, "CLOBBER");
2601 if (CLOBBER_KIND (node) == CLOBBER_EOL)
2602 pp_string (pp, "(eol)");
2603 }
2604 else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
2605 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
2606 is_struct_init = true;
2607 else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE
2608 && TYPE_DOMAIN (TREE_TYPE (node))
2609 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))
2610 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))))
2611 == INTEGER_CST)
2612 {
2613 tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)));
2614 is_array_init = true;
2615 curidx = wi::to_widest (minv);
2616 }
2617 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
2618 {
2619 if (field)
2620 {
2621 if (is_struct_init)
2622 {
2623 pp_dot (pp);
2624 dump_generic_node (pp, field, spc, flags, false);
2625 pp_equal (pp);
2626 }
2627 else if (is_array_init
2628 && (TREE_CODE (field) != INTEGER_CST
2629 || curidx != wi::to_widest (field)))
2630 {
2631 pp_left_bracket (pp);
2632 if (TREE_CODE (field) == RANGE_EXPR)
2633 {
2634 dump_generic_node (pp, TREE_OPERAND (field, 0), spc,
2635 flags, false);
2636 pp_string (pp, " ... ");
2637 dump_generic_node (pp, TREE_OPERAND (field, 1), spc,
2638 flags, false);
2639 if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST)
2640 curidx = wi::to_widest (TREE_OPERAND (field, 1));
2641 }
2642 else
2643 dump_generic_node (pp, field, spc, flags, false);
2644 if (TREE_CODE (field) == INTEGER_CST)
2645 curidx = wi::to_widest (field);
2646 pp_string (pp, "]=");
2647 }
2648 }
2649 if (is_array_init)
2650 curidx += 1;
2651 if (val && TREE_CODE (val) == ADDR_EXPR)
2652 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
2653 val = TREE_OPERAND (val, 0);
2654 if (val && TREE_CODE (val) == FUNCTION_DECL)
2655 dump_decl_name (pp, val, flags);
2656 else
2657 dump_generic_node (pp, val, spc, flags, false);
2658 if (ix != CONSTRUCTOR_NELTS (node) - 1)
2659 {
2660 pp_comma (pp);
2661 pp_space (pp);
2662 }
2663 }
2664 pp_right_brace (pp);
2665 }
2666 break;
2667
2668 case COMPOUND_EXPR:
2669 {
2670 tree *tp;
2671 if (flags & TDF_SLIM)
2672 {
2673 pp_string (pp, "<COMPOUND_EXPR>");
2674 break;
2675 }
2676
2677 dump_generic_node (pp, TREE_OPERAND (node, 0),
2678 spc, flags, !(flags & TDF_SLIM));
2679 if (flags & TDF_SLIM)
2680 newline_and_indent (pp, spc);
2681 else
2682 {
2683 pp_comma (pp);
2684 pp_space (pp);
2685 }
2686
2687 for (tp = &TREE_OPERAND (node, 1);
2688 TREE_CODE (*tp) == COMPOUND_EXPR;
2689 tp = &TREE_OPERAND (*tp, 1))
2690 {
2691 dump_generic_node (pp, TREE_OPERAND (*tp, 0),
2692 spc, flags, !(flags & TDF_SLIM));
2693 if (flags & TDF_SLIM)
2694 newline_and_indent (pp, spc);
2695 else
2696 {
2697 pp_comma (pp);
2698 pp_space (pp);
2699 }
2700 }
2701
2702 dump_generic_node (pp, *tp, spc, flags, !(flags & TDF_SLIM));
2703 }
2704 break;
2705
2706 case STATEMENT_LIST:
2707 {
2708 tree_stmt_iterator si;
2709 bool first = true;
2710
2711 if (flags & TDF_SLIM)
2712 {
2713 pp_string (pp, "<STATEMENT_LIST>");
2714 break;
2715 }
2716
2717 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
2718 {
2719 if (!first)
2720 newline_and_indent (pp, spc);
2721 else
2722 first = false;
2723 dump_generic_node (pp, tsi_stmt (si), spc, flags, true);
2724 }
2725 }
2726 break;
2727
2728 case MODIFY_EXPR:
2729 case INIT_EXPR:
2730 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags,
2731 false);
2732 pp_space (pp);
2733 pp_equal (pp);
2734 pp_space (pp);
2735 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags,
2736 false);
2737 break;
2738
2739 case TARGET_EXPR:
2740 pp_string (pp, "TARGET_EXPR <");
2741 dump_generic_node (pp, TARGET_EXPR_SLOT (node), spc, flags, false);
2742 pp_comma (pp);
2743 pp_space (pp);
2744 dump_generic_node (pp, TARGET_EXPR_INITIAL (node), spc, flags, false);
2745 pp_greater (pp);
2746 break;
2747
2748 case DECL_EXPR:
2749 print_declaration (pp, DECL_EXPR_DECL (node), spc, flags);
2750 is_stmt = false;
2751 break;
2752
2753 case COND_EXPR:
2754 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
2755 {
2756 pp_string (pp, "if (");
2757 dump_generic_node (pp, COND_EXPR_COND (node), spc, flags, false);
2758 pp_right_paren (pp);
2759 /* The lowered cond_exprs should always be printed in full. */
2760 if (COND_EXPR_THEN (node)
2761 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
2762 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
2763 && COND_EXPR_ELSE (node)
2764 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
2765 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
2766 {
2767 pp_space (pp);
2768 dump_generic_node (pp, COND_EXPR_THEN (node),
2769 0, flags, true);
2770 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
2771 {
2772 pp_string (pp, " else ");
2773 dump_generic_node (pp, COND_EXPR_ELSE (node),
2774 0, flags, true);
2775 }
2776 }
2777 else if (!(flags & TDF_SLIM))
2778 {
2779 /* Output COND_EXPR_THEN. */
2780 if (COND_EXPR_THEN (node))
2781 {
2782 newline_and_indent (pp, spc+2);
2783 pp_left_brace (pp);
2784 newline_and_indent (pp, spc+4);
2785 dump_generic_node (pp, COND_EXPR_THEN (node), spc+4,
2786 flags, true);
2787 newline_and_indent (pp, spc+2);
2788 pp_right_brace (pp);
2789 }
2790
2791 /* Output COND_EXPR_ELSE. */
2792 if (COND_EXPR_ELSE (node)
2793 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
2794 {
2795 newline_and_indent (pp, spc);
2796 pp_string (pp, "else");
2797 newline_and_indent (pp, spc+2);
2798 pp_left_brace (pp);
2799 newline_and_indent (pp, spc+4);
2800 dump_generic_node (pp, COND_EXPR_ELSE (node), spc+4,
2801 flags, true);
2802 newline_and_indent (pp, spc+2);
2803 pp_right_brace (pp);
2804 }
2805 }
2806 is_expr = false;
2807 }
2808 else
2809 {
2810 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2811 pp_space (pp);
2812 pp_question (pp);
2813 pp_space (pp);
2814 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2815 pp_space (pp);
2816 pp_colon (pp);
2817 pp_space (pp);
2818 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2819 }
2820 break;
2821
2822 case BIND_EXPR:
2823 pp_left_brace (pp);
2824 if (!(flags & TDF_SLIM))
2825 {
2826 if (BIND_EXPR_VARS (node))
2827 {
2828 pp_newline (pp);
2829
2830 for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0))
2831 {
2832 print_declaration (pp, op0, spc+2, flags);
2833 pp_newline (pp);
2834 }
2835 }
2836
2837 newline_and_indent (pp, spc+2);
2838 dump_generic_node (pp, BIND_EXPR_BODY (node), spc+2, flags, true);
2839 newline_and_indent (pp, spc);
2840 pp_right_brace (pp);
2841 }
2842 is_expr = false;
2843 break;
2844
2845 case CALL_EXPR:
2846 if (CALL_EXPR_FN (node) != NULL_TREE)
2847 print_call_name (pp, CALL_EXPR_FN (node), flags);
2848 else
2849 {
2850 pp_dot (pp);
2851 pp_string (pp, internal_fn_name (CALL_EXPR_IFN (node)));
2852 }
2853
2854 /* Print parameters. */
2855 pp_space (pp);
2856 pp_left_paren (pp);
2857 {
2858 tree arg;
2859 call_expr_arg_iterator iter;
2860 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
2861 {
2862 dump_generic_node (pp, arg, spc, flags, false);
2863 if (more_call_expr_args_p (&iter))
2864 {
2865 pp_comma (pp);
2866 pp_space (pp);
2867 }
2868 }
2869 }
2870 if (CALL_EXPR_VA_ARG_PACK (node))
2871 {
2872 if (call_expr_nargs (node) > 0)
2873 {
2874 pp_comma (pp);
2875 pp_space (pp);
2876 }
2877 pp_string (pp, "__builtin_va_arg_pack ()");
2878 }
2879 pp_right_paren (pp);
2880
2881 op1 = CALL_EXPR_STATIC_CHAIN (node);
2882 if (op1)
2883 {
2884 pp_string (pp, " [static-chain: ");
2885 dump_generic_node (pp, op1, spc, flags, false);
2886 pp_right_bracket (pp);
2887 }
2888
2889 if (CALL_EXPR_RETURN_SLOT_OPT (node))
2890 pp_string (pp, " [return slot optimization]");
2891 if (CALL_EXPR_TAILCALL (node))
2892 pp_string (pp, " [tail call]");
2893 break;
2894
2895 case WITH_CLEANUP_EXPR:
2896 NIY;
2897 break;
2898
2899 case CLEANUP_POINT_EXPR:
2900 pp_string (pp, "<<cleanup_point ");
2901 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2902 pp_string (pp, ">>");
2903 break;
2904
2905 case PLACEHOLDER_EXPR:
2906 pp_string (pp, "<PLACEHOLDER_EXPR ");
2907 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2908 pp_greater (pp);
2909 break;
2910
2911 /* Binary arithmetic and logic expressions. */
2912 case WIDEN_SUM_EXPR:
2913 case WIDEN_MULT_EXPR:
2914 case MULT_EXPR:
2915 case MULT_HIGHPART_EXPR:
2916 case PLUS_EXPR:
2917 case POINTER_PLUS_EXPR:
2918 case POINTER_DIFF_EXPR:
2919 case MINUS_EXPR:
2920 case TRUNC_DIV_EXPR:
2921 case CEIL_DIV_EXPR:
2922 case FLOOR_DIV_EXPR:
2923 case ROUND_DIV_EXPR:
2924 case TRUNC_MOD_EXPR:
2925 case CEIL_MOD_EXPR:
2926 case FLOOR_MOD_EXPR:
2927 case ROUND_MOD_EXPR:
2928 case RDIV_EXPR:
2929 case EXACT_DIV_EXPR:
2930 case LSHIFT_EXPR:
2931 case RSHIFT_EXPR:
2932 case LROTATE_EXPR:
2933 case RROTATE_EXPR:
2934 case WIDEN_LSHIFT_EXPR:
2935 case BIT_IOR_EXPR:
2936 case BIT_XOR_EXPR:
2937 case BIT_AND_EXPR:
2938 case TRUTH_ANDIF_EXPR:
2939 case TRUTH_ORIF_EXPR:
2940 case TRUTH_AND_EXPR:
2941 case TRUTH_OR_EXPR:
2942 case TRUTH_XOR_EXPR:
2943 case LT_EXPR:
2944 case LE_EXPR:
2945 case GT_EXPR:
2946 case GE_EXPR:
2947 case EQ_EXPR:
2948 case NE_EXPR:
2949 case UNLT_EXPR:
2950 case UNLE_EXPR:
2951 case UNGT_EXPR:
2952 case UNGE_EXPR:
2953 case UNEQ_EXPR:
2954 case LTGT_EXPR:
2955 case ORDERED_EXPR:
2956 case UNORDERED_EXPR:
2957 {
2958 const char *op = op_symbol (node);
2959 op0 = TREE_OPERAND (node, 0);
2960 op1 = TREE_OPERAND (node, 1);
2961
2962 /* When the operands are expressions with less priority,
2963 keep semantics of the tree representation. */
2964 if (op_prio (op0) <= op_prio (node))
2965 {
2966 pp_left_paren (pp);
2967 dump_generic_node (pp, op0, spc, flags, false);
2968 pp_right_paren (pp);
2969 }
2970 else
2971 dump_generic_node (pp, op0, spc, flags, false);
2972
2973 pp_space (pp);
2974 pp_string (pp, op);
2975 pp_space (pp);
2976
2977 /* When the operands are expressions with less priority,
2978 keep semantics of the tree representation. */
2979 if (op_prio (op1) <= op_prio (node))
2980 {
2981 pp_left_paren (pp);
2982 dump_generic_node (pp, op1, spc, flags, false);
2983 pp_right_paren (pp);
2984 }
2985 else
2986 dump_generic_node (pp, op1, spc, flags, false);
2987 }
2988 break;
2989
2990 /* Unary arithmetic and logic expressions. */
2991 case ADDR_EXPR:
2992 if (flags & TDF_GIMPLE_VAL)
2993 {
2994 pp_string (pp, "_Literal (");
2995 dump_generic_node (pp, TREE_TYPE (node), spc,
2996 flags & ~TDF_GIMPLE_VAL, false);
2997 pp_character (pp, ')');
2998 }
2999 /* Fallthru. */
3000 case NEGATE_EXPR:
3001 case BIT_NOT_EXPR:
3002 case TRUTH_NOT_EXPR:
3003 case PREDECREMENT_EXPR:
3004 case PREINCREMENT_EXPR:
3005 case INDIRECT_REF:
3006 if (!(flags & TDF_GIMPLE)
3007 && TREE_CODE (node) == ADDR_EXPR
3008 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
3009 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
3010 /* Do not output '&' for strings and function pointers when not
3011 dumping GIMPLE FE syntax. */
3012 ;
3013 else
3014 pp_string (pp, op_symbol (node));
3015
3016 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
3017 {
3018 pp_left_paren (pp);
3019 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3020 pp_right_paren (pp);
3021 }
3022 else
3023 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3024 break;
3025
3026 case POSTDECREMENT_EXPR:
3027 case POSTINCREMENT_EXPR:
3028 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
3029 {
3030 pp_left_paren (pp);
3031 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3032 pp_right_paren (pp);
3033 }
3034 else
3035 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3036 pp_string (pp, op_symbol (node));
3037 break;
3038
3039 case MIN_EXPR:
3040 pp_string (pp, "MIN_EXPR <");
3041 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3042 pp_string (pp, ", ");
3043 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3044 pp_greater (pp);
3045 break;
3046
3047 case MAX_EXPR:
3048 pp_string (pp, "MAX_EXPR <");
3049 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3050 pp_string (pp, ", ");
3051 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3052 pp_greater (pp);
3053 break;
3054
3055 case ABS_EXPR:
3056 pp_string (pp, "ABS_EXPR <");
3057 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3058 pp_greater (pp);
3059 break;
3060
3061 case ABSU_EXPR:
3062 pp_string (pp, "ABSU_EXPR <");
3063 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3064 pp_greater (pp);
3065 break;
3066
3067 case RANGE_EXPR:
3068 NIY;
3069 break;
3070
3071 case ADDR_SPACE_CONVERT_EXPR:
3072 case FIXED_CONVERT_EXPR:
3073 case FIX_TRUNC_EXPR:
3074 case FLOAT_EXPR:
3075 CASE_CONVERT:
3076 type = TREE_TYPE (node);
3077 op0 = TREE_OPERAND (node, 0);
3078 if (type != TREE_TYPE (op0))
3079 {
3080 pp_left_paren (pp);
3081 dump_generic_node (pp, type, spc, flags, false);
3082 pp_string (pp, ") ");
3083 }
3084 if (op_prio (op0) < op_prio (node))
3085 pp_left_paren (pp);
3086 dump_generic_node (pp, op0, spc, flags, false);
3087 if (op_prio (op0) < op_prio (node))
3088 pp_right_paren (pp);
3089 break;
3090
3091 case VIEW_CONVERT_EXPR:
3092 if (flags & TDF_GIMPLE)
3093 pp_string (pp, "__VIEW_CONVERT <");
3094 else
3095 pp_string (pp, "VIEW_CONVERT_EXPR<");
3096 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
3097 pp_string (pp, ">(");
3098 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3099 pp_right_paren (pp);
3100 break;
3101
3102 case PAREN_EXPR:
3103 pp_string (pp, "((");
3104 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3105 pp_string (pp, "))");
3106 break;
3107
3108 case NON_LVALUE_EXPR:
3109 pp_string (pp, "NON_LVALUE_EXPR <");
3110 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3111 pp_greater (pp);
3112 break;
3113
3114 case SAVE_EXPR:
3115 pp_string (pp, "SAVE_EXPR <");
3116 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3117 pp_greater (pp);
3118 break;
3119
3120 case COMPLEX_EXPR:
3121 pp_string (pp, "COMPLEX_EXPR <");
3122 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3123 pp_string (pp, ", ");
3124 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3125 pp_greater (pp);
3126 break;
3127
3128 case CONJ_EXPR:
3129 pp_string (pp, "CONJ_EXPR <");
3130 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3131 pp_greater (pp);
3132 break;
3133
3134 case REALPART_EXPR:
3135 if (flags & TDF_GIMPLE)
3136 {
3137 pp_string (pp, "__real ");
3138 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3139 }
3140 else
3141 {
3142 pp_string (pp, "REALPART_EXPR <");
3143 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3144 pp_greater (pp);
3145 }
3146 break;
3147
3148 case IMAGPART_EXPR:
3149 if (flags & TDF_GIMPLE)
3150 {
3151 pp_string (pp, "__imag ");
3152 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3153 }
3154 else
3155 {
3156 pp_string (pp, "IMAGPART_EXPR <");
3157 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3158 pp_greater (pp);
3159 }
3160 break;
3161
3162 case VA_ARG_EXPR:
3163 pp_string (pp, "VA_ARG_EXPR <");
3164 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3165 pp_greater (pp);
3166 break;
3167
3168 case TRY_FINALLY_EXPR:
3169 case TRY_CATCH_EXPR:
3170 pp_string (pp, "try");
3171 newline_and_indent (pp, spc+2);
3172 pp_left_brace (pp);
3173 newline_and_indent (pp, spc+4);
3174 dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, flags, true);
3175 newline_and_indent (pp, spc+2);
3176 pp_right_brace (pp);
3177 newline_and_indent (pp, spc);
3178 if (TREE_CODE (node) == TRY_CATCH_EXPR)
3179 {
3180 node = TREE_OPERAND (node, 1);
3181 pp_string (pp, "catch");
3182 }
3183 else
3184 {
3185 gcc_assert (TREE_CODE (node) == TRY_FINALLY_EXPR);
3186 node = TREE_OPERAND (node, 1);
3187 pp_string (pp, "finally");
3188 if (TREE_CODE (node) == EH_ELSE_EXPR)
3189 {
3190 newline_and_indent (pp, spc+2);
3191 pp_left_brace (pp);
3192 newline_and_indent (pp, spc+4);
3193 dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4,
3194 flags, true);
3195 newline_and_indent (pp, spc+2);
3196 pp_right_brace (pp);
3197 newline_and_indent (pp, spc);
3198 node = TREE_OPERAND (node, 1);
3199 pp_string (pp, "else");
3200 }
3201 }
3202 newline_and_indent (pp, spc+2);
3203 pp_left_brace (pp);
3204 newline_and_indent (pp, spc+4);
3205 dump_generic_node (pp, node, spc+4, flags, true);
3206 newline_and_indent (pp, spc+2);
3207 pp_right_brace (pp);
3208 is_expr = false;
3209 break;
3210
3211 case CATCH_EXPR:
3212 pp_string (pp, "catch (");
3213 dump_generic_node (pp, CATCH_TYPES (node), spc+2, flags, false);
3214 pp_right_paren (pp);
3215 newline_and_indent (pp, spc+2);
3216 pp_left_brace (pp);
3217 newline_and_indent (pp, spc+4);
3218 dump_generic_node (pp, CATCH_BODY (node), spc+4, flags, true);
3219 newline_and_indent (pp, spc+2);
3220 pp_right_brace (pp);
3221 is_expr = false;
3222 break;
3223
3224 case EH_FILTER_EXPR:
3225 pp_string (pp, "<<<eh_filter (");
3226 dump_generic_node (pp, EH_FILTER_TYPES (node), spc+2, flags, false);
3227 pp_string (pp, ")>>>");
3228 newline_and_indent (pp, spc+2);
3229 pp_left_brace (pp);
3230 newline_and_indent (pp, spc+4);
3231 dump_generic_node (pp, EH_FILTER_FAILURE (node), spc+4, flags, true);
3232 newline_and_indent (pp, spc+2);
3233 pp_right_brace (pp);
3234 is_expr = false;
3235 break;
3236
3237 case LABEL_EXPR:
3238 op0 = TREE_OPERAND (node, 0);
3239 /* If this is for break or continue, don't bother printing it. */
3240 if (DECL_NAME (op0))
3241 {
3242 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
3243 if (strcmp (name, "break") == 0
3244 || strcmp (name, "continue") == 0)
3245 break;
3246 }
3247 dump_generic_node (pp, op0, spc, flags, false);
3248 pp_colon (pp);
3249 if (DECL_NONLOCAL (op0))
3250 pp_string (pp, " [non-local]");
3251 break;
3252
3253 case LOOP_EXPR:
3254 pp_string (pp, "while (1)");
3255 if (!(flags & TDF_SLIM))
3256 {
3257 newline_and_indent (pp, spc+2);
3258 pp_left_brace (pp);
3259 newline_and_indent (pp, spc+4);
3260 dump_generic_node (pp, LOOP_EXPR_BODY (node), spc+4, flags, true);
3261 newline_and_indent (pp, spc+2);
3262 pp_right_brace (pp);
3263 }
3264 is_expr = false;
3265 break;
3266
3267 case PREDICT_EXPR:
3268 pp_string (pp, "// predicted ");
3269 if (PREDICT_EXPR_OUTCOME (node))
3270 pp_string (pp, "likely by ");
3271 else
3272 pp_string (pp, "unlikely by ");
3273 pp_string (pp, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
3274 pp_string (pp, " predictor.");
3275 break;
3276
3277 case ANNOTATE_EXPR:
3278 pp_string (pp, "ANNOTATE_EXPR <");
3279 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3280 switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1)))
3281 {
3282 case annot_expr_ivdep_kind:
3283 pp_string (pp, ", ivdep");
3284 break;
3285 case annot_expr_unroll_kind:
3286 {
3287 pp_string (pp, ", unroll ");
3288 pp_decimal_int (pp,
3289 (int) TREE_INT_CST_LOW (TREE_OPERAND (node, 2)));
3290 break;
3291 }
3292 case annot_expr_no_vector_kind:
3293 pp_string (pp, ", no-vector");
3294 break;
3295 case annot_expr_vector_kind:
3296 pp_string (pp, ", vector");
3297 break;
3298 case annot_expr_parallel_kind:
3299 pp_string (pp, ", parallel");
3300 break;
3301 default:
3302 gcc_unreachable ();
3303 }
3304 pp_greater (pp);
3305 break;
3306
3307 case RETURN_EXPR:
3308 pp_string (pp, "return");
3309 op0 = TREE_OPERAND (node, 0);
3310 if (op0)
3311 {
3312 pp_space (pp);
3313 if (TREE_CODE (op0) == MODIFY_EXPR)
3314 dump_generic_node (pp, TREE_OPERAND (op0, 1),
3315 spc, flags, false);
3316 else
3317 dump_generic_node (pp, op0, spc, flags, false);
3318 }
3319 break;
3320
3321 case EXIT_EXPR:
3322 pp_string (pp, "if (");
3323 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3324 pp_string (pp, ") break");
3325 break;
3326
3327 case SWITCH_EXPR:
3328 pp_string (pp, "switch (");
3329 dump_generic_node (pp, SWITCH_COND (node), spc, flags, false);
3330 pp_right_paren (pp);
3331 if (!(flags & TDF_SLIM))
3332 {
3333 newline_and_indent (pp, spc+2);
3334 pp_left_brace (pp);
3335 if (SWITCH_BODY (node))
3336 {
3337 newline_and_indent (pp, spc+4);
3338 dump_generic_node (pp, SWITCH_BODY (node), spc+4, flags,
3339 true);
3340 }
3341 newline_and_indent (pp, spc+2);
3342 pp_right_brace (pp);
3343 }
3344 is_expr = false;
3345 break;
3346
3347 case GOTO_EXPR:
3348 op0 = GOTO_DESTINATION (node);
3349 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
3350 {
3351 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
3352 if (strcmp (name, "break") == 0
3353 || strcmp (name, "continue") == 0)
3354 {
3355 pp_string (pp, name);
3356 break;
3357 }
3358 }
3359 pp_string (pp, "goto ");
3360 dump_generic_node (pp, op0, spc, flags, false);
3361 break;
3362
3363 case ASM_EXPR:
3364 pp_string (pp, "__asm__");
3365 if (ASM_VOLATILE_P (node))
3366 pp_string (pp, " __volatile__");
3367 pp_left_paren (pp);
3368 dump_generic_node (pp, ASM_STRING (node), spc, flags, false);
3369 pp_colon (pp);
3370 dump_generic_node (pp, ASM_OUTPUTS (node), spc, flags, false);
3371 pp_colon (pp);
3372 dump_generic_node (pp, ASM_INPUTS (node), spc, flags, false);
3373 if (ASM_CLOBBERS (node))
3374 {
3375 pp_colon (pp);
3376 dump_generic_node (pp, ASM_CLOBBERS (node), spc, flags, false);
3377 }
3378 pp_right_paren (pp);
3379 break;
3380
3381 case CASE_LABEL_EXPR:
3382 if (CASE_LOW (node) && CASE_HIGH (node))
3383 {
3384 pp_string (pp, "case ");
3385 dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
3386 pp_string (pp, " ... ");
3387 dump_generic_node (pp, CASE_HIGH (node), spc, flags, false);
3388 }
3389 else if (CASE_LOW (node))
3390 {
3391 pp_string (pp, "case ");
3392 dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
3393 }
3394 else
3395 pp_string (pp, "default");
3396 pp_colon (pp);
3397 break;
3398
3399 case OBJ_TYPE_REF:
3400 pp_string (pp, "OBJ_TYPE_REF(");
3401 dump_generic_node (pp, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
3402 pp_semicolon (pp);
3403 /* We omit the class type for -fcompare-debug because we may
3404 drop TYPE_BINFO early depending on debug info, and then
3405 virtual_method_call_p would return false, whereas when
3406 TYPE_BINFO is preserved it may still return true and then
3407 we'd print the class type. Compare tree and rtl dumps for
3408 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
3409 for example, at occurrences of OBJ_TYPE_REF. */
3410 if (!(flags & (TDF_SLIM | TDF_COMPARE_DEBUG))
3411 && virtual_method_call_p (node, true))
3412 {
3413 pp_string (pp, "(");
3414 dump_generic_node (pp, obj_type_ref_class (node, true),
3415 spc, flags, false);
3416 pp_string (pp, ")");
3417 }
3418 dump_generic_node (pp, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
3419 pp_arrow (pp);
3420 dump_generic_node (pp, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
3421 pp_right_paren (pp);
3422 break;
3423
3424 case SSA_NAME:
3425 if (SSA_NAME_IDENTIFIER (node))
3426 {
3427 if ((flags & TDF_NOUID)
3428 && SSA_NAME_VAR (node)
3429 && DECL_NAMELESS (SSA_NAME_VAR (node)))
3430 dump_fancy_name (pp, SSA_NAME_IDENTIFIER (node));
3431 else if (! (flags & TDF_GIMPLE)
3432 || SSA_NAME_VAR (node))
3433 dump_generic_node (pp, SSA_NAME_IDENTIFIER (node),
3434 spc, flags, false);
3435 }
3436 pp_underscore (pp);
3437 pp_decimal_int (pp, SSA_NAME_VERSION (node));
3438 if (SSA_NAME_IS_DEFAULT_DEF (node))
3439 pp_string (pp, "(D)");
3440 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
3441 pp_string (pp, "(ab)");
3442 break;
3443
3444 case WITH_SIZE_EXPR:
3445 pp_string (pp, "WITH_SIZE_EXPR <");
3446 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3447 pp_string (pp, ", ");
3448 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3449 pp_greater (pp);
3450 break;
3451
3452 case SCEV_KNOWN:
3453 pp_string (pp, "scev_known");
3454 break;
3455
3456 case SCEV_NOT_KNOWN:
3457 pp_string (pp, "scev_not_known");
3458 break;
3459
3460 case POLYNOMIAL_CHREC:
3461 pp_left_brace (pp);
3462 dump_generic_node (pp, CHREC_LEFT (node), spc, flags, false);
3463 pp_string (pp, ", +, ");
3464 dump_generic_node (pp, CHREC_RIGHT (node), spc, flags, false);
3465 pp_string (pp, "}_");
3466 pp_scalar (pp, "%u", CHREC_VARIABLE (node));
3467 is_stmt = false;
3468 break;
3469
3470 case REALIGN_LOAD_EXPR:
3471 pp_string (pp, "REALIGN_LOAD <");
3472 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3473 pp_string (pp, ", ");
3474 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3475 pp_string (pp, ", ");
3476 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3477 pp_greater (pp);
3478 break;
3479
3480 case VEC_COND_EXPR:
3481 pp_string (pp, " VEC_COND_EXPR < ");
3482 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3483 pp_string (pp, " , ");
3484 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3485 pp_string (pp, " , ");
3486 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3487 pp_string (pp, " > ");
3488 break;
3489
3490 case VEC_PERM_EXPR:
3491 pp_string (pp, " VEC_PERM_EXPR < ");
3492 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3493 pp_string (pp, " , ");
3494 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3495 pp_string (pp, " , ");
3496 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3497 pp_string (pp, " > ");
3498 break;
3499
3500 case DOT_PROD_EXPR:
3501 pp_string (pp, " DOT_PROD_EXPR < ");
3502 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3503 pp_string (pp, ", ");
3504 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3505 pp_string (pp, ", ");
3506 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3507 pp_string (pp, " > ");
3508 break;
3509
3510 case WIDEN_MULT_PLUS_EXPR:
3511 pp_string (pp, " WIDEN_MULT_PLUS_EXPR < ");
3512 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3513 pp_string (pp, ", ");
3514 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3515 pp_string (pp, ", ");
3516 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3517 pp_string (pp, " > ");
3518 break;
3519
3520 case WIDEN_MULT_MINUS_EXPR:
3521 pp_string (pp, " WIDEN_MULT_MINUS_EXPR < ");
3522 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3523 pp_string (pp, ", ");
3524 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3525 pp_string (pp, ", ");
3526 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3527 pp_string (pp, " > ");
3528 break;
3529
3530 case OACC_PARALLEL:
3531 pp_string (pp, "#pragma acc parallel");
3532 goto dump_omp_clauses_body;
3533
3534 case OACC_KERNELS:
3535 pp_string (pp, "#pragma acc kernels");
3536 goto dump_omp_clauses_body;
3537
3538 case OACC_SERIAL:
3539 pp_string (pp, "#pragma acc serial");
3540 goto dump_omp_clauses_body;
3541
3542 case OACC_DATA:
3543 pp_string (pp, "#pragma acc data");
3544 dump_omp_clauses (pp, OACC_DATA_CLAUSES (node), spc, flags);
3545 goto dump_omp_body;
3546
3547 case OACC_HOST_DATA:
3548 pp_string (pp, "#pragma acc host_data");
3549 dump_omp_clauses (pp, OACC_HOST_DATA_CLAUSES (node), spc, flags);
3550 goto dump_omp_body;
3551
3552 case OACC_DECLARE:
3553 pp_string (pp, "#pragma acc declare");
3554 dump_omp_clauses (pp, OACC_DECLARE_CLAUSES (node), spc, flags);
3555 break;
3556
3557 case OACC_UPDATE:
3558 pp_string (pp, "#pragma acc update");
3559 dump_omp_clauses (pp, OACC_UPDATE_CLAUSES (node), spc, flags);
3560 break;
3561
3562 case OACC_ENTER_DATA:
3563 pp_string (pp, "#pragma acc enter data");
3564 dump_omp_clauses (pp, OACC_ENTER_DATA_CLAUSES (node), spc, flags);
3565 break;
3566
3567 case OACC_EXIT_DATA:
3568 pp_string (pp, "#pragma acc exit data");
3569 dump_omp_clauses (pp, OACC_EXIT_DATA_CLAUSES (node), spc, flags);
3570 break;
3571
3572 case OACC_CACHE:
3573 pp_string (pp, "#pragma acc cache");
3574 dump_omp_clauses (pp, OACC_CACHE_CLAUSES (node), spc, flags);
3575 break;
3576
3577 case OMP_PARALLEL:
3578 pp_string (pp, "#pragma omp parallel");
3579 dump_omp_clauses (pp, OMP_PARALLEL_CLAUSES (node), spc, flags);
3580 goto dump_omp_body;
3581
3582 dump_omp_clauses_body:
3583 dump_omp_clauses (pp, OMP_CLAUSES (node), spc, flags);
3584 goto dump_omp_body;
3585
3586 dump_omp_body:
3587 if (!(flags & TDF_SLIM) && OMP_BODY (node))
3588 {
3589 newline_and_indent (pp, spc + 2);
3590 pp_left_brace (pp);
3591 newline_and_indent (pp, spc + 4);
3592 dump_generic_node (pp, OMP_BODY (node), spc + 4, flags, false);
3593 newline_and_indent (pp, spc + 2);
3594 pp_right_brace (pp);
3595 }
3596 is_expr = false;
3597 break;
3598
3599 case OMP_TASK:
3600 pp_string (pp, OMP_TASK_BODY (node) ? "#pragma omp task"
3601 : "#pragma omp taskwait");
3602 dump_omp_clauses (pp, OMP_TASK_CLAUSES (node), spc, flags);
3603 goto dump_omp_body;
3604
3605 case OMP_FOR:
3606 pp_string (pp, "#pragma omp for");
3607 goto dump_omp_loop;
3608
3609 case OMP_SIMD:
3610 pp_string (pp, "#pragma omp simd");
3611 goto dump_omp_loop;
3612
3613 case OMP_DISTRIBUTE:
3614 pp_string (pp, "#pragma omp distribute");
3615 goto dump_omp_loop;
3616
3617 case OMP_TASKLOOP:
3618 pp_string (pp, "#pragma omp taskloop");
3619 goto dump_omp_loop;
3620
3621 case OMP_LOOP:
3622 pp_string (pp, "#pragma omp loop");
3623 goto dump_omp_loop;
3624
3625 case OACC_LOOP:
3626 pp_string (pp, "#pragma acc loop");
3627 goto dump_omp_loop;
3628
3629 case OMP_TEAMS:
3630 pp_string (pp, "#pragma omp teams");
3631 dump_omp_clauses (pp, OMP_TEAMS_CLAUSES (node), spc, flags);
3632 goto dump_omp_body;
3633
3634 case OMP_TARGET_DATA:
3635 pp_string (pp, "#pragma omp target data");
3636 dump_omp_clauses (pp, OMP_TARGET_DATA_CLAUSES (node), spc, flags);
3637 goto dump_omp_body;
3638
3639 case OMP_TARGET_ENTER_DATA:
3640 pp_string (pp, "#pragma omp target enter data");
3641 dump_omp_clauses (pp, OMP_TARGET_ENTER_DATA_CLAUSES (node), spc, flags);
3642 is_expr = false;
3643 break;
3644
3645 case OMP_TARGET_EXIT_DATA:
3646 pp_string (pp, "#pragma omp target exit data");
3647 dump_omp_clauses (pp, OMP_TARGET_EXIT_DATA_CLAUSES (node), spc, flags);
3648 is_expr = false;
3649 break;
3650
3651 case OMP_TARGET:
3652 pp_string (pp, "#pragma omp target");
3653 dump_omp_clauses (pp, OMP_TARGET_CLAUSES (node), spc, flags);
3654 goto dump_omp_body;
3655
3656 case OMP_TARGET_UPDATE:
3657 pp_string (pp, "#pragma omp target update");
3658 dump_omp_clauses (pp, OMP_TARGET_UPDATE_CLAUSES (node), spc, flags);
3659 is_expr = false;
3660 break;
3661
3662 dump_omp_loop:
3663 dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
3664 if (!(flags & TDF_SLIM))
3665 {
3666 int i;
3667
3668 if (OMP_FOR_PRE_BODY (node))
3669 {
3670 newline_and_indent (pp, spc + 2);
3671 pp_left_brace (pp);
3672 spc += 4;
3673 newline_and_indent (pp, spc);
3674 dump_generic_node (pp, OMP_FOR_PRE_BODY (node),
3675 spc, flags, false);
3676 }
3677 if (OMP_FOR_INIT (node))
3678 {
3679 spc -= 2;
3680 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
3681 {
3682 spc += 2;
3683 newline_and_indent (pp, spc);
3684 pp_string (pp, "for (");
3685 tree init = TREE_VEC_ELT (OMP_FOR_INIT (node), i);
3686 if (TREE_CODE (init) != MODIFY_EXPR
3687 || TREE_CODE (TREE_OPERAND (init, 1)) != TREE_VEC)
3688 dump_generic_node (pp, init, spc, flags, false);
3689 else
3690 {
3691 dump_generic_node (pp, TREE_OPERAND (init, 0),
3692 spc, flags, false);
3693 pp_string (pp, " = ");
3694 dump_omp_loop_non_rect_expr (pp, TREE_OPERAND (init, 1),
3695 spc, flags);
3696 }
3697 pp_string (pp, "; ");
3698 tree cond = TREE_VEC_ELT (OMP_FOR_COND (node), i);
3699 if (!COMPARISON_CLASS_P (cond)
3700 || TREE_CODE (TREE_OPERAND (cond, 1)) != TREE_VEC)
3701 dump_generic_node (pp, cond, spc, flags, false);
3702 else
3703 {
3704 dump_generic_node (pp, TREE_OPERAND (cond, 0),
3705 spc, flags, false);
3706 const char *op = op_symbol (cond);
3707 pp_space (pp);
3708 pp_string (pp, op);
3709 pp_space (pp);
3710 dump_omp_loop_non_rect_expr (pp, TREE_OPERAND (cond, 1),
3711 spc, flags);
3712 }
3713 pp_string (pp, "; ");
3714 dump_generic_node (pp,
3715 TREE_VEC_ELT (OMP_FOR_INCR (node), i),
3716 spc, flags, false);
3717 pp_right_paren (pp);
3718 }
3719 }
3720 if (OMP_FOR_BODY (node))
3721 {
3722 newline_and_indent (pp, spc + 2);
3723 pp_left_brace (pp);
3724 newline_and_indent (pp, spc + 4);
3725 dump_generic_node (pp, OMP_FOR_BODY (node), spc + 4, flags,
3726 false);
3727 newline_and_indent (pp, spc + 2);
3728 pp_right_brace (pp);
3729 }
3730 if (OMP_FOR_INIT (node))
3731 spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
3732 if (OMP_FOR_PRE_BODY (node))
3733 {
3734 spc -= 4;
3735 newline_and_indent (pp, spc + 2);
3736 pp_right_brace (pp);
3737 }
3738 }
3739 is_expr = false;
3740 break;
3741
3742 case OMP_SECTIONS:
3743 pp_string (pp, "#pragma omp sections");
3744 dump_omp_clauses (pp, OMP_SECTIONS_CLAUSES (node), spc, flags);
3745 goto dump_omp_body;
3746
3747 case OMP_SECTION:
3748 pp_string (pp, "#pragma omp section");
3749 goto dump_omp_body;
3750
3751 case OMP_STRUCTURED_BLOCK:
3752 pp_string (pp, "#pragma omp __structured_block");
3753 goto dump_omp_body;
3754
3755 case OMP_SCAN:
3756 if (OMP_SCAN_CLAUSES (node))
3757 {
3758 pp_string (pp, "#pragma omp scan");
3759 dump_omp_clauses (pp, OMP_SCAN_CLAUSES (node), spc, flags);
3760 }
3761 goto dump_omp_body;
3762
3763 case OMP_MASTER:
3764 pp_string (pp, "#pragma omp master");
3765 goto dump_omp_body;
3766
3767 case OMP_MASKED:
3768 pp_string (pp, "#pragma omp masked");
3769 dump_omp_clauses (pp, OMP_MASKED_CLAUSES (node), spc, flags);
3770 goto dump_omp_body;
3771
3772 case OMP_TASKGROUP:
3773 pp_string (pp, "#pragma omp taskgroup");
3774 dump_omp_clauses (pp, OMP_TASKGROUP_CLAUSES (node), spc, flags);
3775 goto dump_omp_body;
3776
3777 case OMP_ORDERED:
3778 pp_string (pp, "#pragma omp ordered");
3779 dump_omp_clauses (pp, OMP_ORDERED_CLAUSES (node), spc, flags);
3780 goto dump_omp_body;
3781
3782 case OMP_CRITICAL:
3783 pp_string (pp, "#pragma omp critical");
3784 if (OMP_CRITICAL_NAME (node))
3785 {
3786 pp_space (pp);
3787 pp_left_paren (pp);
3788 dump_generic_node (pp, OMP_CRITICAL_NAME (node), spc,
3789 flags, false);
3790 pp_right_paren (pp);
3791 }
3792 dump_omp_clauses (pp, OMP_CRITICAL_CLAUSES (node), spc, flags);
3793 goto dump_omp_body;
3794
3795 case OMP_ATOMIC:
3796 pp_string (pp, "#pragma omp atomic");
3797 if (OMP_ATOMIC_WEAK (node))
3798 pp_string (pp, " weak");
3799 dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
3800 newline_and_indent (pp, spc + 2);
3801 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3802 pp_space (pp);
3803 pp_equal (pp);
3804 pp_space (pp);
3805 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3806 break;
3807
3808 case OMP_ATOMIC_READ:
3809 pp_string (pp, "#pragma omp atomic read");
3810 dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
3811 newline_and_indent (pp, spc + 2);
3812 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3813 pp_space (pp);
3814 break;
3815
3816 case OMP_ATOMIC_CAPTURE_OLD:
3817 case OMP_ATOMIC_CAPTURE_NEW:
3818 pp_string (pp, "#pragma omp atomic capture");
3819 if (OMP_ATOMIC_WEAK (node))
3820 pp_string (pp, " weak");
3821 dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
3822 newline_and_indent (pp, spc + 2);
3823 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3824 pp_space (pp);
3825 pp_equal (pp);
3826 pp_space (pp);
3827 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3828 break;
3829
3830 case OMP_SINGLE:
3831 pp_string (pp, "#pragma omp single");
3832 dump_omp_clauses (pp, OMP_SINGLE_CLAUSES (node), spc, flags);
3833 goto dump_omp_body;
3834
3835 case OMP_SCOPE:
3836 pp_string (pp, "#pragma omp scope");
3837 dump_omp_clauses (pp, OMP_SCOPE_CLAUSES (node), spc, flags);
3838 goto dump_omp_body;
3839
3840 case OMP_CLAUSE:
3841 /* If we come here, we're dumping something that's not an OMP construct,
3842 for example, OMP clauses attached to a function's '__attribute__'.
3843 Dump the whole OMP clause chain. */
3844 dump_omp_clauses (pp, node, spc, flags, false);
3845 is_expr = false;
3846 break;
3847
3848 case TRANSACTION_EXPR:
3849 if (TRANSACTION_EXPR_OUTER (node))
3850 pp_string (pp, "__transaction_atomic [[outer]]");
3851 else if (TRANSACTION_EXPR_RELAXED (node))
3852 pp_string (pp, "__transaction_relaxed");
3853 else
3854 pp_string (pp, "__transaction_atomic");
3855 if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
3856 {
3857 newline_and_indent (pp, spc);
3858 pp_left_brace (pp);
3859 newline_and_indent (pp, spc + 2);
3860 dump_generic_node (pp, TRANSACTION_EXPR_BODY (node),
3861 spc + 2, flags, false);
3862 newline_and_indent (pp, spc);
3863 pp_right_brace (pp);
3864 }
3865 is_expr = false;
3866 break;
3867
3868 case VEC_SERIES_EXPR:
3869 case VEC_WIDEN_MULT_HI_EXPR:
3870 case VEC_WIDEN_MULT_LO_EXPR:
3871 case VEC_WIDEN_MULT_EVEN_EXPR:
3872 case VEC_WIDEN_MULT_ODD_EXPR:
3873 case VEC_WIDEN_LSHIFT_HI_EXPR:
3874 case VEC_WIDEN_LSHIFT_LO_EXPR:
3875 pp_space (pp);
3876 for (str = get_tree_code_name (code); *str; str++)
3877 pp_character (pp, TOUPPER (*str));
3878 pp_string (pp, " < ");
3879 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3880 pp_string (pp, ", ");
3881 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3882 pp_string (pp, " > ");
3883 break;
3884
3885 case VEC_DUPLICATE_EXPR:
3886 pp_space (pp);
3887 for (str = get_tree_code_name (code); *str; str++)
3888 pp_character (pp, TOUPPER (*str));
3889 pp_string (pp, " < ");
3890 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3891 pp_string (pp, " > ");
3892 break;
3893
3894 case VEC_UNPACK_HI_EXPR:
3895 pp_string (pp, " VEC_UNPACK_HI_EXPR < ");
3896 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3897 pp_string (pp, " > ");
3898 break;
3899
3900 case VEC_UNPACK_LO_EXPR:
3901 pp_string (pp, " VEC_UNPACK_LO_EXPR < ");
3902 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3903 pp_string (pp, " > ");
3904 break;
3905
3906 case VEC_UNPACK_FLOAT_HI_EXPR:
3907 pp_string (pp, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3908 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3909 pp_string (pp, " > ");
3910 break;
3911
3912 case VEC_UNPACK_FLOAT_LO_EXPR:
3913 pp_string (pp, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3914 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3915 pp_string (pp, " > ");
3916 break;
3917
3918 case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
3919 pp_string (pp, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
3920 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3921 pp_string (pp, " > ");
3922 break;
3923
3924 case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
3925 pp_string (pp, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
3926 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3927 pp_string (pp, " > ");
3928 break;
3929
3930 case VEC_PACK_TRUNC_EXPR:
3931 pp_string (pp, " VEC_PACK_TRUNC_EXPR < ");
3932 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3933 pp_string (pp, ", ");
3934 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3935 pp_string (pp, " > ");
3936 break;
3937
3938 case VEC_PACK_SAT_EXPR:
3939 pp_string (pp, " VEC_PACK_SAT_EXPR < ");
3940 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3941 pp_string (pp, ", ");
3942 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3943 pp_string (pp, " > ");
3944 break;
3945
3946 case VEC_PACK_FIX_TRUNC_EXPR:
3947 pp_string (pp, " VEC_PACK_FIX_TRUNC_EXPR < ");
3948 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3949 pp_string (pp, ", ");
3950 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3951 pp_string (pp, " > ");
3952 break;
3953
3954 case VEC_PACK_FLOAT_EXPR:
3955 pp_string (pp, " VEC_PACK_FLOAT_EXPR < ");
3956 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3957 pp_string (pp, ", ");
3958 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3959 pp_string (pp, " > ");
3960 break;
3961
3962 case BLOCK:
3963 dump_block_node (pp, node, spc, flags);
3964 break;
3965
3966 case DEBUG_BEGIN_STMT:
3967 pp_string (pp, "# DEBUG BEGIN STMT");
3968 break;
3969
3970 default:
3971 NIY;
3972 }
3973
3974 if (is_stmt && is_expr)
3975 pp_semicolon (pp);
3976
3977 return spc;
3978 }
3979
3980 /* Print the declaration of a variable. */
3981
3982 void
3983 print_declaration (pretty_printer *pp, tree t, int spc, dump_flags_t flags)
3984 {
3985 INDENT (spc);
3986
3987 if (TREE_CODE(t) == NAMELIST_DECL)
3988 {
3989 pp_string(pp, "namelist ");
3990 dump_decl_name (pp, t, flags);
3991 pp_semicolon (pp);
3992 return;
3993 }
3994
3995 if (TREE_CODE (t) == TYPE_DECL)
3996 pp_string (pp, "typedef ");
3997
3998 if (HAS_RTL_P (t) && DECL_REGISTER (t))
3999 pp_string (pp, "register ");
4000
4001 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
4002 pp_string (pp, "extern ");
4003 else if (TREE_STATIC (t))
4004 pp_string (pp, "static ");
4005
4006 /* Print the type and name. */
4007 if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
4008 {
4009 tree tmp;
4010
4011 /* Print array's type. */
4012 tmp = TREE_TYPE (t);
4013 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
4014 tmp = TREE_TYPE (tmp);
4015 dump_generic_node (pp, TREE_TYPE (tmp), spc, flags, false);
4016
4017 /* Print variable's name. */
4018 pp_space (pp);
4019 dump_generic_node (pp, t, spc, flags, false);
4020
4021 /* Print the dimensions. */
4022 tmp = TREE_TYPE (t);
4023 while (TREE_CODE (tmp) == ARRAY_TYPE)
4024 {
4025 dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
4026 tmp = TREE_TYPE (tmp);
4027 }
4028 }
4029 else if (TREE_CODE (t) == FUNCTION_DECL)
4030 {
4031 dump_generic_node (pp, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
4032 pp_space (pp);
4033 dump_decl_name (pp, t, flags);
4034 dump_function_declaration (pp, TREE_TYPE (t), spc, flags);
4035 }
4036 else
4037 {
4038 /* Print type declaration. */
4039 dump_generic_node (pp, TREE_TYPE (t), spc, flags, false);
4040
4041 /* Print variable's name. */
4042 pp_space (pp);
4043 dump_generic_node (pp, t, spc, flags, false);
4044 }
4045
4046 if (VAR_P (t) && DECL_HARD_REGISTER (t))
4047 {
4048 pp_string (pp, " __asm__ ");
4049 pp_left_paren (pp);
4050 dump_generic_node (pp, DECL_ASSEMBLER_NAME (t), spc, flags, false);
4051 pp_right_paren (pp);
4052 }
4053
4054 /* The initial value of a function serves to determine whether the function
4055 is declared or defined. So the following does not apply to function
4056 nodes. */
4057 if (TREE_CODE (t) != FUNCTION_DECL)
4058 {
4059 /* Print the initial value. */
4060 if (DECL_INITIAL (t))
4061 {
4062 pp_space (pp);
4063 pp_equal (pp);
4064 pp_space (pp);
4065 if (!(flags & TDF_SLIM))
4066 dump_generic_node (pp, DECL_INITIAL (t), spc, flags, false);
4067 else
4068 pp_string (pp, "<<< omitted >>>");
4069 }
4070 }
4071
4072 if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t))
4073 {
4074 pp_string (pp, " [value-expr: ");
4075 dump_generic_node (pp, DECL_VALUE_EXPR (t), spc, flags, false);
4076 pp_right_bracket (pp);
4077 }
4078
4079 pp_semicolon (pp);
4080 }
4081
4082
4083 /* Prints a structure: name, fields, and methods.
4084 FIXME: Still incomplete. */
4085
4086 static void
4087 print_struct_decl (pretty_printer *pp, const_tree node, int spc,
4088 dump_flags_t flags)
4089 {
4090 /* Print the name of the structure. */
4091 if (TYPE_NAME (node))
4092 {
4093 INDENT (spc);
4094 if (TREE_CODE (node) == RECORD_TYPE)
4095 pp_string (pp, "struct ");
4096 else if ((TREE_CODE (node) == UNION_TYPE
4097 || TREE_CODE (node) == QUAL_UNION_TYPE))
4098 pp_string (pp, "union ");
4099
4100 dump_generic_node (pp, TYPE_NAME (node), spc, TDF_NONE, false);
4101 }
4102
4103 /* Print the contents of the structure. */
4104 pp_newline (pp);
4105 INDENT (spc);
4106 pp_left_brace (pp);
4107 pp_newline (pp);
4108
4109 /* Print the fields of the structure. */
4110 {
4111 tree tmp;
4112 tmp = TYPE_FIELDS (node);
4113 while (tmp)
4114 {
4115 /* Avoid to print recursively the structure. */
4116 /* FIXME : Not implemented correctly...,
4117 what about the case when we have a cycle in the contain graph? ...
4118 Maybe this could be solved by looking at the scope in which the
4119 structure was declared. */
4120 if (TREE_TYPE (tmp) != node
4121 && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
4122 || TREE_TYPE (TREE_TYPE (tmp)) != node))
4123 {
4124 print_declaration (pp, tmp, spc+2, flags);
4125 pp_newline (pp);
4126 }
4127 tmp = DECL_CHAIN (tmp);
4128 }
4129 }
4130 INDENT (spc);
4131 pp_right_brace (pp);
4132 }
4133
4134 /* Return the priority of the operator CODE.
4135
4136 From lowest to highest precedence with either left-to-right (L-R)
4137 or right-to-left (R-L) associativity]:
4138
4139 1 [L-R] ,
4140 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
4141 3 [R-L] ?:
4142 4 [L-R] ||
4143 5 [L-R] &&
4144 6 [L-R] |
4145 7 [L-R] ^
4146 8 [L-R] &
4147 9 [L-R] == !=
4148 10 [L-R] < <= > >=
4149 11 [L-R] << >>
4150 12 [L-R] + -
4151 13 [L-R] * / %
4152 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
4153 15 [L-R] fn() [] -> .
4154
4155 unary +, - and * have higher precedence than the corresponding binary
4156 operators. */
4157
4158 int
4159 op_code_prio (enum tree_code code)
4160 {
4161 switch (code)
4162 {
4163 case TREE_LIST:
4164 case COMPOUND_EXPR:
4165 case BIND_EXPR:
4166 return 1;
4167
4168 case MODIFY_EXPR:
4169 case INIT_EXPR:
4170 return 2;
4171
4172 case COND_EXPR:
4173 return 3;
4174
4175 case TRUTH_OR_EXPR:
4176 case TRUTH_ORIF_EXPR:
4177 return 4;
4178
4179 case TRUTH_AND_EXPR:
4180 case TRUTH_ANDIF_EXPR:
4181 return 5;
4182
4183 case BIT_IOR_EXPR:
4184 return 6;
4185
4186 case BIT_XOR_EXPR:
4187 case TRUTH_XOR_EXPR:
4188 return 7;
4189
4190 case BIT_AND_EXPR:
4191 return 8;
4192
4193 case EQ_EXPR:
4194 case NE_EXPR:
4195 return 9;
4196
4197 case UNLT_EXPR:
4198 case UNLE_EXPR:
4199 case UNGT_EXPR:
4200 case UNGE_EXPR:
4201 case UNEQ_EXPR:
4202 case LTGT_EXPR:
4203 case ORDERED_EXPR:
4204 case UNORDERED_EXPR:
4205 case LT_EXPR:
4206 case LE_EXPR:
4207 case GT_EXPR:
4208 case GE_EXPR:
4209 return 10;
4210
4211 case LSHIFT_EXPR:
4212 case RSHIFT_EXPR:
4213 case LROTATE_EXPR:
4214 case RROTATE_EXPR:
4215 case VEC_WIDEN_LSHIFT_HI_EXPR:
4216 case VEC_WIDEN_LSHIFT_LO_EXPR:
4217 case WIDEN_LSHIFT_EXPR:
4218 return 11;
4219
4220 case WIDEN_SUM_EXPR:
4221 case PLUS_EXPR:
4222 case POINTER_PLUS_EXPR:
4223 case POINTER_DIFF_EXPR:
4224 case MINUS_EXPR:
4225 return 12;
4226
4227 case VEC_WIDEN_MULT_HI_EXPR:
4228 case VEC_WIDEN_MULT_LO_EXPR:
4229 case WIDEN_MULT_EXPR:
4230 case DOT_PROD_EXPR:
4231 case WIDEN_MULT_PLUS_EXPR:
4232 case WIDEN_MULT_MINUS_EXPR:
4233 case MULT_EXPR:
4234 case MULT_HIGHPART_EXPR:
4235 case TRUNC_DIV_EXPR:
4236 case CEIL_DIV_EXPR:
4237 case FLOOR_DIV_EXPR:
4238 case ROUND_DIV_EXPR:
4239 case RDIV_EXPR:
4240 case EXACT_DIV_EXPR:
4241 case TRUNC_MOD_EXPR:
4242 case CEIL_MOD_EXPR:
4243 case FLOOR_MOD_EXPR:
4244 case ROUND_MOD_EXPR:
4245 return 13;
4246
4247 case TRUTH_NOT_EXPR:
4248 case BIT_NOT_EXPR:
4249 case POSTINCREMENT_EXPR:
4250 case POSTDECREMENT_EXPR:
4251 case PREINCREMENT_EXPR:
4252 case PREDECREMENT_EXPR:
4253 case NEGATE_EXPR:
4254 case INDIRECT_REF:
4255 case ADDR_EXPR:
4256 case FLOAT_EXPR:
4257 CASE_CONVERT:
4258 case FIX_TRUNC_EXPR:
4259 case TARGET_EXPR:
4260 return 14;
4261
4262 case CALL_EXPR:
4263 case ARRAY_REF:
4264 case ARRAY_RANGE_REF:
4265 case COMPONENT_REF:
4266 return 15;
4267
4268 /* Special expressions. */
4269 case MIN_EXPR:
4270 case MAX_EXPR:
4271 case ABS_EXPR:
4272 case REALPART_EXPR:
4273 case IMAGPART_EXPR:
4274 case VEC_UNPACK_HI_EXPR:
4275 case VEC_UNPACK_LO_EXPR:
4276 case VEC_UNPACK_FLOAT_HI_EXPR:
4277 case VEC_UNPACK_FLOAT_LO_EXPR:
4278 case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
4279 case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
4280 case VEC_PACK_TRUNC_EXPR:
4281 case VEC_PACK_SAT_EXPR:
4282 return 16;
4283
4284 default:
4285 /* Return an arbitrarily high precedence to avoid surrounding single
4286 VAR_DECLs in ()s. */
4287 return 9999;
4288 }
4289 }
4290
4291 /* Return the priority of the operator OP. */
4292
4293 int
4294 op_prio (const_tree op)
4295 {
4296 enum tree_code code;
4297
4298 if (op == NULL)
4299 return 9999;
4300
4301 code = TREE_CODE (op);
4302 if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
4303 return op_prio (TREE_OPERAND (op, 0));
4304
4305 return op_code_prio (code);
4306 }
4307
4308 /* Return the symbol associated with operator CODE. */
4309
4310 const char *
4311 op_symbol_code (enum tree_code code)
4312 {
4313 switch (code)
4314 {
4315 case MODIFY_EXPR:
4316 return "=";
4317
4318 case TRUTH_OR_EXPR:
4319 case TRUTH_ORIF_EXPR:
4320 return "||";
4321
4322 case TRUTH_AND_EXPR:
4323 case TRUTH_ANDIF_EXPR:
4324 return "&&";
4325
4326 case BIT_IOR_EXPR:
4327 return "|";
4328
4329 case TRUTH_XOR_EXPR:
4330 case BIT_XOR_EXPR:
4331 return "^";
4332
4333 case ADDR_EXPR:
4334 case BIT_AND_EXPR:
4335 return "&";
4336
4337 case ORDERED_EXPR:
4338 return "ord";
4339 case UNORDERED_EXPR:
4340 return "unord";
4341
4342 case EQ_EXPR:
4343 return "==";
4344 case UNEQ_EXPR:
4345 return "u==";
4346
4347 case NE_EXPR:
4348 return "!=";
4349
4350 case LT_EXPR:
4351 return "<";
4352 case UNLT_EXPR:
4353 return "u<";
4354
4355 case LE_EXPR:
4356 return "<=";
4357 case UNLE_EXPR:
4358 return "u<=";
4359
4360 case GT_EXPR:
4361 return ">";
4362 case UNGT_EXPR:
4363 return "u>";
4364
4365 case GE_EXPR:
4366 return ">=";
4367 case UNGE_EXPR:
4368 return "u>=";
4369
4370 case LTGT_EXPR:
4371 return "<>";
4372
4373 case LSHIFT_EXPR:
4374 return "<<";
4375
4376 case RSHIFT_EXPR:
4377 return ">>";
4378
4379 case LROTATE_EXPR:
4380 return "r<<";
4381
4382 case RROTATE_EXPR:
4383 return "r>>";
4384
4385 case WIDEN_LSHIFT_EXPR:
4386 return "w<<";
4387
4388 case POINTER_PLUS_EXPR:
4389 return "+";
4390
4391 case PLUS_EXPR:
4392 return "+";
4393
4394 case WIDEN_SUM_EXPR:
4395 return "w+";
4396
4397 case WIDEN_MULT_EXPR:
4398 return "w*";
4399
4400 case MULT_HIGHPART_EXPR:
4401 return "h*";
4402
4403 case NEGATE_EXPR:
4404 case MINUS_EXPR:
4405 case POINTER_DIFF_EXPR:
4406 return "-";
4407
4408 case BIT_NOT_EXPR:
4409 return "~";
4410
4411 case TRUTH_NOT_EXPR:
4412 return "!";
4413
4414 case MULT_EXPR:
4415 case INDIRECT_REF:
4416 return "*";
4417
4418 case TRUNC_DIV_EXPR:
4419 case RDIV_EXPR:
4420 return "/";
4421
4422 case CEIL_DIV_EXPR:
4423 return "/[cl]";
4424
4425 case FLOOR_DIV_EXPR:
4426 return "/[fl]";
4427
4428 case ROUND_DIV_EXPR:
4429 return "/[rd]";
4430
4431 case EXACT_DIV_EXPR:
4432 return "/[ex]";
4433
4434 case TRUNC_MOD_EXPR:
4435 return "%";
4436
4437 case CEIL_MOD_EXPR:
4438 return "%[cl]";
4439
4440 case FLOOR_MOD_EXPR:
4441 return "%[fl]";
4442
4443 case ROUND_MOD_EXPR:
4444 return "%[rd]";
4445
4446 case PREDECREMENT_EXPR:
4447 return " --";
4448
4449 case PREINCREMENT_EXPR:
4450 return " ++";
4451
4452 case POSTDECREMENT_EXPR:
4453 return "-- ";
4454
4455 case POSTINCREMENT_EXPR:
4456 return "++ ";
4457
4458 case MAX_EXPR:
4459 return "max";
4460
4461 case MIN_EXPR:
4462 return "min";
4463
4464 default:
4465 return "<<< ??? >>>";
4466 }
4467 }
4468
4469 /* Return the symbol associated with operator OP. */
4470
4471 static const char *
4472 op_symbol (const_tree op)
4473 {
4474 return op_symbol_code (TREE_CODE (op));
4475 }
4476
4477 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
4478 the gimple_call_fn of a GIMPLE_CALL. */
4479
4480 void
4481 print_call_name (pretty_printer *pp, tree node, dump_flags_t flags)
4482 {
4483 tree op0 = node;
4484 int spc = 0;
4485
4486 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
4487 op0 = TREE_OPERAND (op0, 0);
4488
4489 again:
4490 switch (TREE_CODE (op0))
4491 {
4492 case VAR_DECL:
4493 case PARM_DECL:
4494 case FUNCTION_DECL:
4495 dump_function_name (pp, op0, flags);
4496 break;
4497
4498 case ADDR_EXPR:
4499 case INDIRECT_REF:
4500 CASE_CONVERT:
4501 op0 = TREE_OPERAND (op0, 0);
4502 goto again;
4503
4504 case COND_EXPR:
4505 pp_left_paren (pp);
4506 dump_generic_node (pp, TREE_OPERAND (op0, 0), 0, flags, false);
4507 pp_string (pp, ") ? ");
4508 dump_generic_node (pp, TREE_OPERAND (op0, 1), 0, flags, false);
4509 pp_string (pp, " : ");
4510 dump_generic_node (pp, TREE_OPERAND (op0, 2), 0, flags, false);
4511 break;
4512
4513 case ARRAY_REF:
4514 if (VAR_P (TREE_OPERAND (op0, 0)))
4515 dump_function_name (pp, TREE_OPERAND (op0, 0), flags);
4516 else
4517 dump_generic_node (pp, op0, 0, flags, false);
4518 break;
4519
4520 case MEM_REF:
4521 if (integer_zerop (TREE_OPERAND (op0, 1)))
4522 {
4523 op0 = TREE_OPERAND (op0, 0);
4524 goto again;
4525 }
4526 /* Fallthru. */
4527 case COMPONENT_REF:
4528 case SSA_NAME:
4529 case OBJ_TYPE_REF:
4530 dump_generic_node (pp, op0, 0, flags, false);
4531 break;
4532
4533 default:
4534 NIY;
4535 }
4536 }
4537
4538 /* Print the first N characters in the array STR, replacing non-printable
4539 characters (including embedded nuls) with unambiguous escape sequences. */
4540
4541 void
4542 pretty_print_string (pretty_printer *pp, const char *str, size_t n)
4543 {
4544 if (str == NULL)
4545 return;
4546
4547 for ( ; n; --n, ++str)
4548 {
4549 switch (str[0])
4550 {
4551 case '\b':
4552 pp_string (pp, "\\b");
4553 break;
4554
4555 case '\f':
4556 pp_string (pp, "\\f");
4557 break;
4558
4559 case '\n':
4560 pp_string (pp, "\\n");
4561 break;
4562
4563 case '\r':
4564 pp_string (pp, "\\r");
4565 break;
4566
4567 case '\t':
4568 pp_string (pp, "\\t");
4569 break;
4570
4571 case '\v':
4572 pp_string (pp, "\\v");
4573 break;
4574
4575 case '\\':
4576 pp_string (pp, "\\\\");
4577 break;
4578
4579 case '\"':
4580 pp_string (pp, "\\\"");
4581 break;
4582
4583 case '\'':
4584 pp_string (pp, "\\'");
4585 break;
4586
4587 default:
4588 if (str[0] || n > 1)
4589 {
4590 if (!ISPRINT (str[0]))
4591 {
4592 char buf[5];
4593 sprintf (buf, "\\x%02x", (unsigned char)str[0]);
4594 pp_string (pp, buf);
4595 }
4596 else
4597 pp_character (pp, str[0]);
4598 break;
4599 }
4600 }
4601 }
4602 }
4603
4604 static void
4605 maybe_init_pretty_print (FILE *file)
4606 {
4607 if (!tree_pp)
4608 {
4609 tree_pp = new pretty_printer ();
4610 pp_needs_newline (tree_pp) = true;
4611 pp_translate_identifiers (tree_pp) = false;
4612 }
4613
4614 tree_pp->buffer->stream = file;
4615 }
4616
4617 static void
4618 newline_and_indent (pretty_printer *pp, int spc)
4619 {
4620 pp_newline (pp);
4621 INDENT (spc);
4622 }
4623
4624 /* Print the identifier ID to PRETTY-PRINTER. */
4625
4626 void
4627 pp_tree_identifier (pretty_printer *pp, tree id)
4628 {
4629 if (pp_translate_identifiers (pp))
4630 {
4631 const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
4632 pp_append_text (pp, text, text + strlen (text));
4633 }
4634 else
4635 pp_append_text (pp, IDENTIFIER_POINTER (id),
4636 IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
4637 }
4638
4639 /* A helper function that is used to dump function information before the
4640 function dump. */
4641
4642 void
4643 dump_function_header (FILE *dump_file, tree fdecl, dump_flags_t flags)
4644 {
4645 const char *dname, *aname;
4646 struct cgraph_node *node = cgraph_node::get (fdecl);
4647 struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
4648
4649 dname = lang_hooks.decl_printable_name (fdecl, 1);
4650
4651 if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
4652 aname = (IDENTIFIER_POINTER
4653 (DECL_ASSEMBLER_NAME (fdecl)));
4654 else
4655 aname = "<unset-asm-name>";
4656
4657 fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
4658 dname, aname, fun->funcdef_no);
4659 if (!(flags & TDF_NOUID))
4660 fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
4661 if (node)
4662 {
4663 fprintf (dump_file, ", cgraph_uid=%d", node->get_uid ());
4664 fprintf (dump_file, ", symbol_order=%d)%s\n\n", node->order,
4665 node->frequency == NODE_FREQUENCY_HOT
4666 ? " (hot)"
4667 : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
4668 ? " (unlikely executed)"
4669 : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
4670 ? " (executed once)"
4671 : "");
4672 }
4673 else
4674 fprintf (dump_file, ")\n\n");
4675 }
4676
4677 /* Dump double_int D to pretty_printer PP. UNS is true
4678 if D is unsigned and false otherwise. */
4679 void
4680 pp_double_int (pretty_printer *pp, double_int d, bool uns)
4681 {
4682 if (d.fits_shwi ())
4683 pp_wide_integer (pp, d.low);
4684 else if (d.fits_uhwi ())
4685 pp_unsigned_wide_integer (pp, d.low);
4686 else
4687 {
4688 unsigned HOST_WIDE_INT low = d.low;
4689 HOST_WIDE_INT high = d.high;
4690 if (!uns && d.is_negative ())
4691 {
4692 pp_minus (pp);
4693 high = ~high + !low;
4694 low = -low;
4695 }
4696 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4697 systems? */
4698 sprintf (pp_buffer (pp)->digit_buffer,
4699 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4700 (unsigned HOST_WIDE_INT) high, low);
4701 pp_string (pp, pp_buffer (pp)->digit_buffer);
4702 }
4703 }
4704
4705 #if __GNUC__ >= 10
4706 # pragma GCC diagnostic pop
4707 #endif
Mirror of the offical gcc git repository hosted at gcc.gnu.org