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