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