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 13333 : do_niy (pretty_printer *pp, const_tree node, int spc, dump_flags_t flags)
70 : {
71 13333 : int i, len;
72 :
73 13333 : pp_string (pp, "<<< Unknown tree: ");
74 13333 : pp_string (pp, get_tree_code_name (TREE_CODE (node)));
75 :
76 13333 : if (EXPR_P (node))
77 : {
78 13115 : len = TREE_OPERAND_LENGTH (node);
79 43336 : for (i = 0; i < len; ++i)
80 : {
81 17106 : newline_and_indent (pp, spc+2);
82 17106 : dump_generic_node (pp, TREE_OPERAND (node, i), spc+2, flags, false);
83 : }
84 : }
85 :
86 13333 : pp_string (pp, " >>>");
87 13333 : }
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 298834 : print_generic_decl (FILE *file, tree decl, dump_flags_t flags)
133 : {
134 298834 : maybe_init_pretty_print (file);
135 298834 : print_declaration (tree_pp, decl, 2, flags);
136 298834 : pp_write_text_to_stream (tree_pp);
137 298834 : }
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 72325 : print_generic_stmt (FILE *file, tree t, dump_flags_t flags)
144 : {
145 72325 : maybe_init_pretty_print (file);
146 72325 : dump_generic_node (tree_pp, t, 0, flags, true);
147 72325 : pp_newline_and_flush (tree_pp);
148 72325 : }
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 6438 : print_generic_stmt_indented (FILE *file, tree t, dump_flags_t flags, int indent)
156 : {
157 6438 : int i;
158 :
159 6438 : maybe_init_pretty_print (file);
160 :
161 12876 : for (i = 0; i < indent; i++)
162 0 : pp_space (tree_pp);
163 6438 : dump_generic_node (tree_pp, t, indent, flags, true);
164 6438 : pp_newline_and_flush (tree_pp);
165 6438 : }
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 6808598 : print_generic_expr (FILE *file, tree t, dump_flags_t flags)
172 : {
173 6808598 : maybe_init_pretty_print (file);
174 6808598 : dump_generic_node (tree_pp, t, 0, flags, false);
175 6808598 : pp_flush (tree_pp);
176 6808598 : }
177 :
178 : /* Print a single expression T to string, and return it. The caller
179 : must free the returned memory. */
180 :
181 : char *
182 62656 : print_generic_expr_to_str (tree t)
183 : {
184 62656 : pretty_printer pp;
185 62656 : dump_generic_node (&pp, t, 0, TDF_VOPS|TDF_MEMSYMS, false);
186 62656 : return xstrdup (pp_formatted_text (&pp));
187 62656 : }
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 2664 : dump_fancy_name (pretty_printer *pp, tree name)
196 : {
197 2664 : int cnt = 0;
198 2664 : int length = IDENTIFIER_LENGTH (name);
199 2664 : const char *n = IDENTIFIER_POINTER (name);
200 2664 : do
201 : {
202 2664 : n = strchr (n, 'D');
203 2664 : 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 2664 : if (cnt == 0)
223 : {
224 2664 : pp_tree_identifier (pp, name);
225 2664 : 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 6116223 : dump_decl_name (pretty_printer *pp, tree node, dump_flags_t flags)
273 : {
274 6116223 : tree name = DECL_NAME (node);
275 6116223 : if (name)
276 : {
277 5593515 : if ((flags & TDF_ASMNAME)
278 17260 : && HAS_DECL_ASSEMBLER_NAME_P (node)
279 5608760 : && DECL_ASSEMBLER_NAME_SET_P (node))
280 1610 : 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 5591905 : else if ((flags & TDF_COMPARE_DEBUG)
288 44028 : && DECL_NAMELESS (node)
289 5597159 : && 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 5587307 : else if ((flags & TDF_NOUID) && DECL_NAMELESS (node))
294 1462 : dump_fancy_name (pp, name);
295 : else
296 5585845 : pp_tree_identifier (pp, name);
297 : }
298 6116223 : char uid_sep = (flags & TDF_GIMPLE) ? '_' : '.';
299 6116223 : if ((flags & TDF_UID) || name == NULL_TREE)
300 : {
301 544972 : 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 544969 : 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 540470 : char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
320 540470 : pp_character (pp, c);
321 540470 : pp_character (pp, uid_sep);
322 540470 : if (flags & TDF_NOUID)
323 7251 : pp_string (pp, "xxxx");
324 : else
325 533219 : pp_scalar (pp, "%u", DECL_UID (node));
326 : }
327 : }
328 6116223 : 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 6116223 : }
339 :
340 : /* Like the above, but used for pretty printing function calls. */
341 :
342 : static void
343 184502 : dump_function_name (pretty_printer *pp, tree node, dump_flags_t flags)
344 : {
345 184502 : if (CONVERT_EXPR_P (node))
346 0 : node = TREE_OPERAND (node, 0);
347 184502 : if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)
348 : {
349 184119 : pp_string (pp, lang_hooks.decl_printable_name (node, 1));
350 184119 : 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 383 : dump_decl_name (pp, node, flags);
360 184502 : }
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 16398 : dump_function_declaration (pretty_printer *pp, tree node,
367 : int spc, dump_flags_t flags)
368 : {
369 16398 : bool wrote_arg = false;
370 16398 : tree arg;
371 :
372 16398 : pp_space (pp);
373 16398 : pp_left_paren (pp);
374 :
375 : /* Print the argument types. */
376 16398 : arg = TYPE_ARG_TYPES (node);
377 44850 : while (arg && arg != void_list_node && arg != error_mark_node)
378 : {
379 28452 : if (wrote_arg)
380 : {
381 17410 : pp_comma (pp);
382 17410 : pp_space (pp);
383 : }
384 28452 : wrote_arg = true;
385 28452 : dump_generic_node (pp, TREE_VALUE (arg), spc, flags, false);
386 28452 : arg = TREE_CHAIN (arg);
387 : }
388 :
389 : /* Drop the trailing void_type_node if we had any previous argument. */
390 16398 : if (arg == void_list_node && !wrote_arg)
391 2860 : pp_string (pp, "void");
392 : /* Properly dump vararg function types. */
393 13538 : else if (!arg && wrote_arg)
394 115 : pp_string (pp, ", ...");
395 : /* Avoid printing any arg for unprototyped functions. */
396 :
397 16398 : pp_right_paren (pp);
398 16398 : }
399 :
400 : /* Dump the domain associated with an array. */
401 :
402 : static void
403 105147 : dump_array_domain (pretty_printer *pp, tree domain, int spc, dump_flags_t flags)
404 : {
405 105147 : pp_left_bracket (pp);
406 105147 : if (domain)
407 : {
408 104829 : tree min = TYPE_MIN_VALUE (domain);
409 104829 : tree max = TYPE_MAX_VALUE (domain);
410 :
411 104829 : if (min && max
412 81884 : && integer_zerop (min)
413 181875 : && tree_fits_shwi_p (max))
414 72232 : pp_wide_integer (pp, tree_to_shwi (max) + 1);
415 : else
416 : {
417 32597 : if (min)
418 32597 : dump_generic_node (pp, min, spc, flags, false);
419 32597 : pp_colon (pp);
420 32597 : if (max)
421 9652 : dump_generic_node (pp, max, spc, flags, false);
422 : }
423 : }
424 : else
425 318 : pp_string (pp, "<unknown>");
426 105147 : pp_right_bracket (pp);
427 105147 : }
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 30503 : dump_omp_clause (pretty_printer *pp, tree clause, int spc, dump_flags_t flags)
524 : {
525 30503 : const char *name;
526 30503 : const char *modifier = NULL;
527 30503 : switch (OMP_CLAUSE_CODE (clause))
528 : {
529 3277 : case OMP_CLAUSE_PRIVATE:
530 3277 : name = "private";
531 3277 : goto print_remap;
532 1124 : case OMP_CLAUSE_SHARED:
533 1124 : name = "shared";
534 1124 : goto print_remap;
535 1607 : case OMP_CLAUSE_FIRSTPRIVATE:
536 1607 : name = "firstprivate";
537 1607 : 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 8349 : print_remap:
613 8349 : pp_string (pp, name);
614 8349 : pp_left_paren (pp);
615 8349 : if (modifier)
616 36 : pp_string (pp, modifier);
617 8349 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
618 : spc, flags, false);
619 8349 : pp_right_paren (pp);
620 8349 : 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 1240 : case OMP_CLAUSE_REDUCTION:
628 1240 : pp_string (pp, "reduction(");
629 1240 : if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_REDUCTION)
630 : {
631 1216 : if (OMP_CLAUSE_REDUCTION_TASK (clause))
632 12 : pp_string (pp, "task,");
633 1204 : else if (OMP_CLAUSE_REDUCTION_INSCAN (clause))
634 6 : pp_string (pp, "inscan,");
635 : }
636 1240 : if (OMP_CLAUSE_REDUCTION_CODE (clause) != ERROR_MARK)
637 : {
638 1228 : pp_string (pp,
639 1228 : op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
640 1228 : pp_colon (pp);
641 : }
642 1240 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
643 : spc, flags, false);
644 1240 : pp_right_paren (pp);
645 1240 : break;
646 :
647 152 : case OMP_CLAUSE_IF:
648 152 : pp_string (pp, "if(");
649 152 : 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 152 : dump_generic_node (pp, OMP_CLAUSE_IF_EXPR (clause),
666 : spc, flags, false);
667 152 : pp_right_paren (pp);
668 152 : 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 764 : case OMP_CLAUSE_NOWAIT:
733 764 : pp_string (pp, "nowait");
734 764 : 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 1262 : case OMP_CLAUSE_DEFAULT:
747 1262 : pp_string (pp, "default(");
748 1262 : 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 1194 : case OMP_CLAUSE_DEFAULT_NONE:
756 1194 : pp_string (pp, "none");
757 1194 : break;
758 0 : case OMP_CLAUSE_DEFAULT_PRIVATE:
759 0 : pp_string (pp, "private");
760 0 : break;
761 4 : case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
762 4 : pp_string (pp, "firstprivate");
763 4 : 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 1262 : pp_right_paren (pp);
771 1262 : 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 60 : case OMP_CLAUSE_MESSAGE:
844 60 : if (OMP_CLAUSE_MESSAGE_EXPR (clause))
845 : {
846 57 : pp_string (pp, "message(");
847 57 : dump_generic_node (pp, OMP_CLAUSE_MESSAGE_EXPR (clause),
848 : spc, flags, false);
849 57 : if (OMP_CLAUSE_MESSAGE_LEN (clause))
850 : {
851 57 : pp_string (pp, " [len:");
852 57 : dump_generic_node (pp, OMP_CLAUSE_MESSAGE_LEN (clause),
853 : spc, flags, false);
854 57 : pp_right_bracket (pp);
855 : }
856 57 : pp_right_paren (pp);
857 57 : pp_space (pp);
858 : }
859 60 : if (OMP_CLAUSE_MESSAGE_SEVERITY_WARN (clause))
860 16 : pp_string (pp, "severity(warning)");
861 : else
862 44 : pp_string (pp, "severity(fatal)");
863 : break;
864 :
865 1911 : case OMP_CLAUSE_LINEAR:
866 1911 : pp_string (pp, "linear(");
867 1911 : 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 1911 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
885 : spc, flags, false);
886 1911 : if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
887 1911 : && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
888 4 : pp_right_paren (pp);
889 1911 : pp_colon (pp);
890 1911 : if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
891 1911 : && 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 1911 : dump_generic_node (pp, OMP_CLAUSE_LINEAR_STEP (clause),
907 : spc, flags, false);
908 1911 : if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
909 1911 : && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
910 81 : pp_right_paren (pp);
911 1911 : pp_right_paren (pp);
912 1911 : 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 6537 : case OMP_CLAUSE_MAP:
1073 6537 : pp_string (pp, "map(");
1074 6537 : if (OMP_CLAUSE_MAP_READONLY (clause))
1075 70 : pp_string (pp, "readonly,");
1076 6537 : 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 6537 : 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 825 : case GOMP_MAP_TO:
1092 825 : case GOMP_MAP_TO_PSET:
1093 825 : pp_string (pp, "to");
1094 825 : break;
1095 602 : case GOMP_MAP_FROM:
1096 602 : pp_string (pp, "from");
1097 602 : break;
1098 2249 : case GOMP_MAP_TOFROM:
1099 2249 : pp_string (pp, "tofrom");
1100 2249 : 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 347 : case GOMP_MAP_FIRSTPRIVATE_POINTER:
1135 347 : pp_string (pp, "firstprivate");
1136 347 : break;
1137 0 : case GOMP_MAP_FIRSTPRIVATE_REFERENCE:
1138 0 : pp_string (pp, "firstprivate ref");
1139 0 : break;
1140 151 : case GOMP_MAP_STRUCT:
1141 151 : pp_string (pp, "struct");
1142 151 : break;
1143 3 : case GOMP_MAP_STRUCT_UNORD:
1144 3 : pp_string (pp, "struct_unord");
1145 3 : break;
1146 67 : case GOMP_MAP_ALWAYS_POINTER:
1147 67 : pp_string (pp, "always_pointer");
1148 67 : 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 6537 : pp_colon (pp);
1207 6537 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
1208 : spc, flags, false);
1209 6795 : print_clause_size:
1210 6795 : if (OMP_CLAUSE_SIZE (clause))
1211 : {
1212 11423 : switch (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
1213 5782 : ? OMP_CLAUSE_MAP_KIND (clause) : GOMP_MAP_TO)
1214 : {
1215 999 : case GOMP_MAP_POINTER:
1216 999 : case GOMP_MAP_FIRSTPRIVATE_POINTER:
1217 999 : case GOMP_MAP_FIRSTPRIVATE_REFERENCE:
1218 999 : case GOMP_MAP_ALWAYS_POINTER:
1219 999 : pp_string (pp, " [pointer assign, bias: ");
1220 999 : 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 4347 : default:
1244 4347 : pp_string (pp, " [len: ");
1245 4347 : break;
1246 : }
1247 5782 : dump_generic_node (pp, OMP_CLAUSE_SIZE (clause),
1248 : spc, flags, false);
1249 5782 : if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
1250 5782 : && OMP_CLAUSE_MAP_SIZE_NEEDS_ADJUSTMENT (clause))
1251 2 : pp_string (pp, " (needs adjustment)");
1252 5782 : pp_right_bracket (pp);
1253 : }
1254 6795 : if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP)
1255 : {
1256 6537 : if (OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P (clause))
1257 841 : pp_string (pp, " [runtime_implicit]");
1258 6537 : if (OMP_CLAUSE_MAP_GIMPLE_ONLY (clause))
1259 1 : pp_string (pp, " [gimple only]");
1260 : }
1261 6795 : pp_right_paren (pp);
1262 6795 : 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 1250 : case OMP_CLAUSE_NUM_TEAMS:
1316 1250 : pp_string (pp, "num_teams(");
1317 1250 : if (OMP_CLAUSE_NUM_TEAMS_DIMS (clause))
1318 35 : pp_string (pp, "dims():");
1319 1250 : if (OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (clause))
1320 : {
1321 19 : dump_generic_node (pp, OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (clause),
1322 : spc, flags, false);
1323 19 : pp_colon (pp);
1324 : }
1325 1250 : dump_generic_node (pp, OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR (clause),
1326 : spc, flags, false);
1327 1250 : pp_right_paren (pp);
1328 1250 : break;
1329 :
1330 1261 : case OMP_CLAUSE_THREAD_LIMIT:
1331 1261 : pp_string (pp, "thread_limit(");
1332 1261 : if (OMP_CLAUSE_THREAD_LIMIT_STRICT (clause))
1333 29 : pp_string (pp, "strict");
1334 1261 : if (OMP_CLAUSE_THREAD_LIMIT_STRICT (clause)
1335 1261 : && OMP_CLAUSE_THREAD_LIMIT_DIMS (clause))
1336 12 : pp_comma (pp);
1337 1261 : if (OMP_CLAUSE_THREAD_LIMIT_DIMS (clause))
1338 18 : pp_string (pp, "dims()");
1339 1261 : if (OMP_CLAUSE_THREAD_LIMIT_STRICT (clause)
1340 1261 : || OMP_CLAUSE_THREAD_LIMIT_DIMS (clause))
1341 35 : pp_colon (pp);
1342 1261 : dump_generic_node (pp, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause),
1343 : spc, flags, false);
1344 1261 : pp_right_paren (pp);
1345 1261 : break;
1346 :
1347 67 : case OMP_CLAUSE_DEVICE:
1348 67 : pp_string (pp, "device(");
1349 67 : if (OMP_CLAUSE_DEVICE_ANCESTOR (clause))
1350 13 : pp_string (pp, "ancestor:");
1351 67 : dump_generic_node (pp, OMP_CLAUSE_DEVICE_ID (clause),
1352 : spc, flags, false);
1353 67 : pp_right_paren (pp);
1354 67 : 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 58 : case OMP_CLAUSE_DYN_GROUPPRIVATE:
1409 58 : pp_string (pp, "dyn_groupprivate(");
1410 58 : switch (OMP_CLAUSE_DYN_GROUPPRIVATE_KIND (clause))
1411 : {
1412 9 : case OMP_CLAUSE_FALLBACK_ABORT:
1413 9 : pp_string (pp, "fallback(abort):");
1414 9 : break;
1415 11 : case OMP_CLAUSE_FALLBACK_DEFAULT_MEM:
1416 11 : pp_string (pp, "fallback(default_mem):");
1417 11 : break;
1418 16 : case OMP_CLAUSE_FALLBACK_NULL:
1419 16 : pp_string (pp, "fallback(null):");
1420 16 : break;
1421 : case OMP_CLAUSE_FALLBACK_UNSPECIFIED:
1422 : break;
1423 : }
1424 58 : dump_generic_node (pp, OMP_CLAUSE_DYN_GROUPPRIVATE_EXPR (clause),
1425 : spc, flags, false);
1426 58 : pp_right_paren (pp);
1427 58 : 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 597 : case OMP_CLAUSE_DEFAULTMAP:
1497 597 : pp_string (pp, "defaultmap(");
1498 597 : 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 39 : case OMP_CLAUSE_DEFAULTMAP_TOFROM:
1510 39 : pp_string (pp, "tofrom");
1511 39 : break;
1512 58 : case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE:
1513 58 : pp_string (pp, "firstprivate");
1514 58 : break;
1515 446 : case OMP_CLAUSE_DEFAULTMAP_NONE:
1516 446 : pp_string (pp, "none");
1517 446 : 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 597 : 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 44 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR:
1535 44 : pp_string (pp, ":scalar");
1536 44 : break;
1537 49 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE:
1538 49 : pp_string (pp, ":aggregate");
1539 49 : break;
1540 12 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE:
1541 12 : pp_string (pp, ":allocatable");
1542 12 : break;
1543 33 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER:
1544 33 : pp_string (pp, ":pointer");
1545 33 : break;
1546 0 : default:
1547 0 : gcc_unreachable ();
1548 : }
1549 597 : pp_right_paren (pp);
1550 597 : break;
1551 :
1552 303 : case OMP_CLAUSE_ORDER:
1553 303 : pp_string (pp, "order(");
1554 303 : if (OMP_CLAUSE_ORDER_UNCONSTRAINED (clause))
1555 20 : pp_string (pp, "unconstrained:");
1556 283 : else if (OMP_CLAUSE_ORDER_REPRODUCIBLE (clause))
1557 20 : pp_string (pp, "reproducible:");
1558 303 : pp_string (pp, "concurrent)");
1559 303 : break;
1560 :
1561 261 : case OMP_CLAUSE_BIND:
1562 261 : pp_string (pp, "bind(");
1563 261 : 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 21 : case OMP_CLAUSE_BIND_THREAD:
1572 21 : pp_string (pp, "thread");
1573 21 : break;
1574 0 : default:
1575 0 : gcc_unreachable ();
1576 : }
1577 261 : pp_right_paren (pp);
1578 261 : 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 30503 : }
1763 :
1764 :
1765 : /* Dump chain of OMP clauses.
1766 :
1767 : PP, SPC and FLAGS are as in dump_generic_node. */
1768 :
1769 : void
1770 13236 : dump_omp_clauses (pretty_printer *pp, tree clause, int spc, dump_flags_t flags,
1771 : bool leading_space)
1772 : {
1773 43716 : while (clause)
1774 : {
1775 30480 : if (leading_space)
1776 28890 : pp_space (pp);
1777 30480 : dump_omp_clause (pp, clause, spc, flags);
1778 30480 : leading_space = true;
1779 :
1780 30480 : clause = OMP_CLAUSE_CHAIN (clause);
1781 : }
1782 13236 : }
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 1355135 : dump_mem_ref (pretty_printer *pp, tree node, int spc, dump_flags_t flags)
2052 : {
2053 1355135 : if ((TREE_CODE (node) == MEM_REF
2054 1355135 : || TREE_CODE (node) == TARGET_MEM_REF)
2055 1355135 : && (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 1355132 : else if (TREE_CODE (node) == MEM_REF
2120 1328105 : && 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 1002865 : && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
2125 : /* Released SSA_NAMES have no TREE_TYPE. */
2126 1002726 : && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
2127 : /* Same pointer types, but ignoring POINTER_TYPE vs.
2128 : REFERENCE_TYPE. */
2129 1002726 : && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
2130 1002726 : == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
2131 1603104 : && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
2132 801552 : == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
2133 801552 : && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
2134 801552 : == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
2135 : /* Same value types ignoring qualifiers. */
2136 801403 : && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
2137 801403 : == TYPE_MAIN_VARIANT
2138 : (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))
2139 2140036 : && (!(flags & TDF_ALIAS)
2140 1483 : || MR_DEPENDENCE_CLIQUE (node) == 0))
2141 : {
2142 783590 : if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
2143 : {
2144 : /* Enclose pointers to arrays in parentheses. */
2145 689839 : tree op0 = TREE_OPERAND (node, 0);
2146 689839 : tree op0type = TREE_TYPE (op0);
2147 689839 : if (POINTER_TYPE_P (op0type)
2148 689839 : && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
2149 30459 : pp_left_paren (pp);
2150 689839 : pp_star (pp);
2151 689839 : dump_generic_node (pp, op0, spc, flags, false);
2152 689839 : if (POINTER_TYPE_P (op0type)
2153 689839 : && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
2154 30459 : pp_right_paren (pp);
2155 : }
2156 : else
2157 93751 : dump_generic_node (pp,
2158 93751 : TREE_OPERAND (TREE_OPERAND (node, 0), 0),
2159 : spc, flags, false);
2160 : }
2161 : else
2162 : {
2163 571542 : pp_string (pp, "MEM");
2164 :
2165 571542 : tree nodetype = TREE_TYPE (node);
2166 571542 : tree op0 = TREE_OPERAND (node, 0);
2167 571542 : tree op1 = TREE_OPERAND (node, 1);
2168 571542 : tree op1type = TYPE_MAIN_VARIANT (TREE_TYPE (op1));
2169 :
2170 571542 : tree op0size = TYPE_SIZE (nodetype);
2171 571542 : tree op1size = TYPE_SIZE (TREE_TYPE (op1type));
2172 :
2173 571542 : if (!op0size || !op1size
2174 571542 : || !operand_equal_p (op0size, op1size, 0))
2175 : {
2176 228883 : 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 228883 : dump_generic_node (pp, nodetype, spc, flags | TDF_SLIM, false);
2182 228883 : pp_string (pp, "> ");
2183 : }
2184 :
2185 571542 : pp_string (pp, "[(");
2186 571542 : dump_generic_node (pp, op1type, spc, flags | TDF_SLIM, false);
2187 571542 : pp_right_paren (pp);
2188 571542 : dump_generic_node (pp, op0, spc, flags, false);
2189 571542 : if (!integer_zerop (op1))
2190 : {
2191 327953 : pp_string (pp, " + ");
2192 327953 : dump_generic_node (pp, op1, spc, flags, false);
2193 : }
2194 571542 : if (TREE_CODE (node) == TARGET_MEM_REF)
2195 : {
2196 27027 : tree tmp = TMR_INDEX2 (node);
2197 27027 : if (tmp)
2198 : {
2199 280 : pp_string (pp, " + ");
2200 280 : dump_generic_node (pp, tmp, spc, flags, false);
2201 : }
2202 27027 : tmp = TMR_INDEX (node);
2203 27027 : if (tmp)
2204 : {
2205 22386 : pp_string (pp, " + ");
2206 22386 : dump_generic_node (pp, tmp, spc, flags, false);
2207 22386 : tmp = TMR_STEP (node);
2208 22386 : pp_string (pp, " * ");
2209 22386 : if (tmp)
2210 22373 : dump_generic_node (pp, tmp, spc, flags, false);
2211 : else
2212 13 : pp_string (pp, "1");
2213 : }
2214 : }
2215 571542 : if ((flags & TDF_ALIAS)
2216 571542 : && 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 571542 : pp_right_bracket (pp);
2224 : }
2225 1355135 : }
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 49719214 : dump_generic_node (pretty_printer *pp, tree node, int spc, dump_flags_t flags,
2263 : bool is_stmt)
2264 : {
2265 49719214 : tree type;
2266 49719214 : tree op0, op1;
2267 49719214 : const char *str;
2268 49719214 : bool is_expr;
2269 49719214 : enum tree_code code;
2270 :
2271 49719214 : if (node == NULL_TREE)
2272 : return spc;
2273 :
2274 49698472 : is_expr = EXPR_P (node);
2275 :
2276 49698472 : 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 49698472 : if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
2284 931 : dump_location (pp, EXPR_LOCATION (node), flags);
2285 :
2286 49698472 : code = TREE_CODE (node);
2287 49698472 : switch (code)
2288 : {
2289 13 : case ERROR_MARK:
2290 13 : pp_string (pp, "<<< error >>>");
2291 13 : break;
2292 :
2293 10267460 : case IDENTIFIER_NODE:
2294 10267460 : pp_tree_identifier (pp, node);
2295 10267460 : break;
2296 :
2297 : case TREE_LIST:
2298 58898 : while (node && node != error_mark_node)
2299 : {
2300 58898 : if (TREE_PURPOSE (node))
2301 : {
2302 22172 : dump_generic_node (pp, TREE_PURPOSE (node), spc, flags, false);
2303 22172 : pp_space (pp);
2304 : }
2305 58898 : dump_generic_node (pp, TREE_VALUE (node), spc, flags, false);
2306 58898 : node = TREE_CHAIN (node);
2307 58898 : if (node && TREE_CODE (node) == TREE_LIST)
2308 : {
2309 2471 : pp_comma (pp);
2310 2471 : 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 159 : case TREE_VEC:
2320 159 : {
2321 159 : size_t i;
2322 159 : pp_left_brace (pp);
2323 159 : if (TREE_VEC_LENGTH (node) > 0)
2324 : {
2325 159 : size_t len = TREE_VEC_LENGTH (node);
2326 477 : for (i = 0; i < len - 1; i++)
2327 : {
2328 318 : dump_generic_node (pp, TREE_VEC_ELT (node, i), spc, flags,
2329 : false);
2330 318 : pp_comma (pp);
2331 318 : pp_space (pp);
2332 : }
2333 159 : dump_generic_node (pp, TREE_VEC_ELT (node, len - 1), spc,
2334 : flags, false);
2335 : }
2336 159 : pp_right_brace (pp);
2337 : }
2338 159 : break;
2339 :
2340 4676987 : case VOID_TYPE:
2341 4676987 : case INTEGER_TYPE:
2342 4676987 : case REAL_TYPE:
2343 4676987 : case FIXED_POINT_TYPE:
2344 4676987 : case COMPLEX_TYPE:
2345 4676987 : case VECTOR_TYPE:
2346 4676987 : case ENUMERAL_TYPE:
2347 4676987 : case BOOLEAN_TYPE:
2348 4676987 : case BITINT_TYPE:
2349 4676987 : case OPAQUE_TYPE:
2350 4676987 : case NULLPTR_TYPE:
2351 4676987 : {
2352 4676987 : auto quals = TYPE_QUALS_NO_ADDR_SPACE (node);
2353 4676987 : enum tree_code_class tclass;
2354 :
2355 4676987 : if (quals & TYPE_QUAL_ATOMIC)
2356 534 : pp_string (pp, "atomic ");
2357 4676987 : if (quals & TYPE_QUAL_CONST)
2358 44816 : pp_string (pp, "const ");
2359 4676987 : if (quals & TYPE_QUAL_VOLATILE)
2360 3791 : pp_string (pp, "volatile ");
2361 4676987 : if (quals & TYPE_QUAL_RESTRICT)
2362 0 : pp_string (pp, "restrict ");
2363 :
2364 4676987 : if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
2365 : {
2366 157 : pp_string (pp, "<address-space-");
2367 157 : pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
2368 157 : pp_string (pp, "> ");
2369 : }
2370 :
2371 4676987 : tclass = TREE_CODE_CLASS (TREE_CODE (node));
2372 :
2373 4676987 : if (tclass == tcc_declaration)
2374 : {
2375 0 : if (DECL_NAME (node))
2376 0 : dump_decl_name (pp, node, flags);
2377 : else
2378 0 : pp_string (pp, "<unnamed type decl>");
2379 : }
2380 4676987 : else if (tclass == tcc_type)
2381 : {
2382 4676987 : if ((flags & TDF_GIMPLE) && node == sizetype)
2383 0 : pp_string (pp, "__SIZETYPE__");
2384 4676987 : else if (TYPE_NAME (node))
2385 : {
2386 3093951 : if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
2387 877657 : pp_tree_identifier (pp, TYPE_NAME (node));
2388 2216294 : else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
2389 2216294 : && DECL_NAME (TYPE_NAME (node)))
2390 2216294 : dump_decl_name (pp, TYPE_NAME (node), flags);
2391 : else
2392 0 : pp_string (pp, "<unnamed type>");
2393 : }
2394 1583036 : else if (TREE_CODE (node) == VECTOR_TYPE)
2395 : {
2396 1055986 : if (flags & TDF_GIMPLE)
2397 : {
2398 0 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2399 0 : pp_string (pp, " [[gnu::vector_size(");
2400 0 : pp_wide_integer
2401 0 : (pp, tree_to_poly_uint64 (TYPE_SIZE_UNIT (node)));
2402 0 : pp_string (pp, ")]]");
2403 : }
2404 : else
2405 : {
2406 1055986 : pp_string (pp, "vector");
2407 1055986 : pp_left_paren (pp);
2408 1055986 : pp_wide_integer (pp, TYPE_VECTOR_SUBPARTS (node));
2409 1055986 : pp_string (pp, ") ");
2410 1055986 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2411 : }
2412 : }
2413 : else if (TREE_CODE (node) == INTEGER_TYPE)
2414 : {
2415 448010 : if (TYPE_PRECISION (node) == CHAR_TYPE_SIZE)
2416 56436 : pp_string (pp, (TYPE_UNSIGNED (node)
2417 : ? "unsigned char"
2418 : : "signed char"));
2419 397762 : else if (TYPE_PRECISION (node) == SHORT_TYPE_SIZE)
2420 184105 : pp_string (pp, (TYPE_UNSIGNED (node)
2421 : ? "unsigned short"
2422 : : "signed short"));
2423 247959 : else if (TYPE_PRECISION (node) == INT_TYPE_SIZE)
2424 203669 : pp_string (pp, (TYPE_UNSIGNED (node)
2425 : ? "unsigned int"
2426 : : "signed int"));
2427 47992 : else if (TYPE_PRECISION (node) == LONG_TYPE_SIZE)
2428 46159 : pp_string (pp, (TYPE_UNSIGNED (node)
2429 : ? "unsigned long"
2430 : : "signed long"));
2431 4242 : else if (TYPE_PRECISION (node) == LONG_LONG_TYPE_SIZE)
2432 0 : pp_string (pp, (TYPE_UNSIGNED (node)
2433 : ? "unsigned long long"
2434 : : "signed long long"));
2435 4242 : else if (TYPE_PRECISION (node) >= CHAR_TYPE_SIZE
2436 4242 : && pow2p_hwi (TYPE_PRECISION (node)))
2437 : {
2438 6149 : pp_string (pp, (TYPE_UNSIGNED (node) ? "uint" : "int"));
2439 3689 : pp_decimal_int (pp, TYPE_PRECISION (node));
2440 3689 : pp_string (pp, "_t");
2441 : }
2442 : else
2443 : {
2444 722 : pp_string (pp, (TYPE_UNSIGNED (node)
2445 : ? "<unnamed-unsigned:"
2446 : : "<unnamed-signed:"));
2447 553 : pp_decimal_int (pp, TYPE_PRECISION (node));
2448 553 : pp_greater (pp);
2449 : }
2450 : }
2451 : else if (TREE_CODE (node) == COMPLEX_TYPE)
2452 : {
2453 6975 : pp_string (pp, "__complex__ ");
2454 6975 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2455 : }
2456 : else if (TREE_CODE (node) == REAL_TYPE)
2457 : {
2458 0 : pp_string (pp, "<float:");
2459 0 : pp_decimal_int (pp, TYPE_PRECISION (node));
2460 0 : pp_greater (pp);
2461 : }
2462 : else if (TREE_CODE (node) == FIXED_POINT_TYPE)
2463 : {
2464 0 : pp_string (pp, "<fixed-point-");
2465 0 : pp_string (pp, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
2466 0 : pp_decimal_int (pp, TYPE_PRECISION (node));
2467 0 : pp_greater (pp);
2468 : }
2469 : else if (TREE_CODE (node) == BOOLEAN_TYPE)
2470 : {
2471 137884 : pp_string (pp, (TYPE_UNSIGNED (node)
2472 : ? "<unsigned-boolean:"
2473 : : "<signed-boolean:"));
2474 68942 : pp_decimal_int (pp, TYPE_PRECISION (node));
2475 68942 : pp_greater (pp);
2476 : }
2477 : else if (TREE_CODE (node) == BITINT_TYPE)
2478 : {
2479 2989 : if (TYPE_UNSIGNED (node))
2480 1983 : pp_string (pp, "unsigned ");
2481 2989 : pp_string (pp, "_BitInt(");
2482 2989 : pp_decimal_int (pp, TYPE_PRECISION (node));
2483 2989 : pp_right_paren (pp);
2484 : }
2485 : else if (TREE_CODE (node) == VOID_TYPE)
2486 13 : pp_string (pp, "void");
2487 : else if (TREE_CODE (node) == NULLPTR_TYPE)
2488 0 : pp_string (pp, "nullptr_t");
2489 : else
2490 121 : pp_string (pp, "<unnamed type>");
2491 : }
2492 : break;
2493 : }
2494 :
2495 880014 : case POINTER_TYPE:
2496 880014 : case REFERENCE_TYPE:
2497 880014 : str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
2498 :
2499 880014 : if (TREE_TYPE (node) == NULL)
2500 : {
2501 0 : pp_string (pp, str);
2502 0 : pp_string (pp, "<null type>");
2503 : }
2504 880014 : else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
2505 : {
2506 7422 : tree fnode = TREE_TYPE (node);
2507 :
2508 7422 : dump_generic_node (pp, TREE_TYPE (fnode), spc, flags, false);
2509 7422 : pp_space (pp);
2510 7422 : pp_left_paren (pp);
2511 7422 : pp_string (pp, str);
2512 7422 : if (TYPE_IDENTIFIER (node))
2513 2448 : dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
2514 4974 : else if (flags & TDF_NOUID)
2515 129 : pp_string (pp, "<Txxxx>");
2516 : else
2517 : {
2518 4845 : pp_string (pp, "<T");
2519 4845 : pp_scalar (pp, "%x", TYPE_UID (node));
2520 4845 : pp_character (pp, '>');
2521 : }
2522 :
2523 7422 : pp_right_paren (pp);
2524 7422 : dump_function_declaration (pp, fnode, spc, flags);
2525 : }
2526 : else
2527 : {
2528 872592 : auto quals = TYPE_QUALS (node);
2529 :
2530 872592 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2531 872592 : pp_space (pp);
2532 872592 : pp_string (pp, str);
2533 :
2534 872592 : if (quals.has (TYPE_QUAL_CONST))
2535 4255 : pp_string (pp, " const");
2536 872592 : if (quals.has (TYPE_QUAL_VOLATILE))
2537 209 : pp_string (pp, " volatile");
2538 872592 : if (quals.has (TYPE_QUAL_RESTRICT))
2539 47226 : pp_string (pp, " restrict");
2540 :
2541 872592 : if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
2542 : {
2543 0 : pp_string (pp, " <address-space-");
2544 0 : pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
2545 0 : pp_greater (pp);
2546 : }
2547 :
2548 872592 : if (TYPE_REF_CAN_ALIAS_ALL (node))
2549 5115 : pp_string (pp, " {ref-all}");
2550 : }
2551 : break;
2552 :
2553 0 : case OFFSET_TYPE:
2554 0 : NIY;
2555 0 : break;
2556 :
2557 1355135 : case MEM_REF:
2558 1355135 : case TARGET_MEM_REF:
2559 1355135 : dump_mem_ref (pp, node, spc, flags);
2560 1355135 : break;
2561 :
2562 72700 : case ARRAY_TYPE:
2563 72700 : {
2564 72700 : auto quals = TYPE_QUALS_NO_ADDR_SPACE (node);
2565 72700 : tree tmp;
2566 :
2567 72700 : if (quals & TYPE_QUAL_ATOMIC)
2568 0 : pp_string (pp, "atomic ");
2569 72700 : if (quals & TYPE_QUAL_CONST)
2570 1 : pp_string (pp, "const ");
2571 72700 : if (quals & TYPE_QUAL_VOLATILE)
2572 0 : pp_string (pp, "volatile ");
2573 :
2574 : /* Print the innermost component type. */
2575 77663 : for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
2576 4963 : tmp = TREE_TYPE (tmp))
2577 : ;
2578 :
2579 : /* Avoid to print recursively the array. */
2580 : /* FIXME : Not implemented correctly, see print_struct_decl. */
2581 72700 : if (TREE_CODE (tmp) != POINTER_TYPE || TREE_TYPE (tmp) != node)
2582 72700 : dump_generic_node (pp, tmp, spc, flags, false);
2583 :
2584 : /* Print the dimensions. */
2585 150363 : for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
2586 77663 : dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
2587 : break;
2588 : }
2589 :
2590 131440 : case RECORD_TYPE:
2591 131440 : case UNION_TYPE:
2592 131440 : case QUAL_UNION_TYPE:
2593 131440 : {
2594 131440 : auto quals = TYPE_QUALS_NO_ADDR_SPACE (node);
2595 :
2596 131440 : if (quals & TYPE_QUAL_ATOMIC)
2597 0 : pp_string (pp, "atomic ");
2598 131440 : if (quals & TYPE_QUAL_CONST)
2599 12558 : pp_string (pp, "const ");
2600 131440 : if (quals & TYPE_QUAL_VOLATILE)
2601 63 : pp_string (pp, "volatile ");
2602 :
2603 131440 : if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
2604 : {
2605 1 : pp_string (pp, "<address-space-");
2606 1 : pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
2607 1 : pp_string (pp, "> ");
2608 : }
2609 :
2610 : /* Print the name of the structure. */
2611 131440 : if (TREE_CODE (node) == RECORD_TYPE)
2612 129599 : pp_string (pp, "struct ");
2613 1841 : else if (TREE_CODE (node) == UNION_TYPE)
2614 1841 : pp_string (pp, "union ");
2615 :
2616 131440 : if (TYPE_NAME (node))
2617 128298 : dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
2618 3142 : else if (!(flags & TDF_SLIM))
2619 : /* FIXME: If we eliminate the 'else' above and attempt
2620 : to show the fields for named types, we may get stuck
2621 : following a cycle of pointers to structs. The alleged
2622 : self-reference check in print_struct_decl will not detect
2623 : cycles involving more than one pointer or struct type. */
2624 580 : print_struct_decl (pp, node, spc, flags);
2625 : break;
2626 : }
2627 :
2628 0 : case LANG_TYPE:
2629 0 : NIY;
2630 0 : break;
2631 :
2632 5737072 : case INTEGER_CST:
2633 5737072 : if (flags & TDF_GIMPLE
2634 5737072 : && (POINTER_TYPE_P (TREE_TYPE (node))
2635 47 : || (TYPE_PRECISION (TREE_TYPE (node))
2636 47 : < TYPE_PRECISION (integer_type_node))
2637 47 : || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1
2638 47 : || tree_int_cst_sgn (node) < 0))
2639 : {
2640 0 : pp_string (pp, "_Literal (");
2641 0 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2642 0 : pp_string (pp, ") ");
2643 : }
2644 5737072 : if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE
2645 5737072 : && ! (flags & TDF_GIMPLE))
2646 : {
2647 : /* In the case of a pointer, one may want to divide by the
2648 : size of the pointed-to type. Unfortunately, this not
2649 : straightforward. The C front-end maps expressions
2650 :
2651 : (int *) 5
2652 : int *p; (p + 5)
2653 :
2654 : in such a way that the two INTEGER_CST nodes for "5" have
2655 : different values but identical types. In the latter
2656 : case, the 5 is multiplied by sizeof (int) in c-common.cc
2657 : (pointer_int_sum) to convert it to a byte address, and
2658 : yet the type of the node is left unchanged. Argh. What
2659 : is consistent though is that the number value corresponds
2660 : to bytes (UNITS) offset.
2661 :
2662 : NB: Neither of the following divisors can be trivially
2663 : used to recover the original literal:
2664 :
2665 : TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
2666 : TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
2667 449138 : pp_wide_integer (pp, TREE_INT_CST_LOW (node));
2668 449138 : pp_string (pp, "B"); /* pseudo-unit */
2669 : }
2670 5287934 : else if (tree_fits_shwi_p (node))
2671 5267472 : pp_wide_integer (pp, tree_to_shwi (node));
2672 20462 : else if (tree_fits_uhwi_p (node))
2673 19904 : pp_unsigned_wide_integer (pp, tree_to_uhwi (node));
2674 : else
2675 : {
2676 558 : wide_int val = wi::to_wide (node);
2677 :
2678 558 : if (wi::neg_p (val, TYPE_SIGN (TREE_TYPE (node))))
2679 : {
2680 11 : pp_minus (pp);
2681 11 : val = -val;
2682 : }
2683 558 : unsigned int len;
2684 558 : print_hex_buf_size (val, &len);
2685 558 : if (UNLIKELY (len > sizeof (pp_buffer (pp)->m_digit_buffer)))
2686 : {
2687 0 : char *buf = XALLOCAVEC (char, len);
2688 0 : print_hex (val, buf);
2689 0 : pp_string (pp, buf);
2690 : }
2691 : else
2692 : {
2693 558 : print_hex (val, pp_buffer (pp)->m_digit_buffer);
2694 558 : pp_string (pp, pp_buffer (pp)->m_digit_buffer);
2695 : }
2696 558 : }
2697 5737072 : if ((flags & TDF_GIMPLE)
2698 5737072 : && ! (POINTER_TYPE_P (TREE_TYPE (node))
2699 47 : || (TYPE_PRECISION (TREE_TYPE (node))
2700 47 : < TYPE_PRECISION (integer_type_node))
2701 47 : || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1))
2702 : {
2703 47 : if (TYPE_UNSIGNED (TREE_TYPE (node)))
2704 0 : pp_character (pp, 'u');
2705 47 : if (TYPE_PRECISION (TREE_TYPE (node))
2706 47 : == TYPE_PRECISION (unsigned_type_node))
2707 : ;
2708 0 : else if (TYPE_PRECISION (TREE_TYPE (node))
2709 0 : == TYPE_PRECISION (long_unsigned_type_node))
2710 0 : pp_character (pp, 'l');
2711 0 : else if (TYPE_PRECISION (TREE_TYPE (node))
2712 0 : == TYPE_PRECISION (long_long_unsigned_type_node))
2713 0 : pp_string (pp, "ll");
2714 : }
2715 5737072 : if (TREE_OVERFLOW (node))
2716 251 : pp_string (pp, "(OVF)");
2717 : break;
2718 :
2719 0 : case POLY_INT_CST:
2720 0 : pp_string (pp, "POLY_INT_CST [");
2721 0 : dump_generic_node (pp, POLY_INT_CST_COEFF (node, 0), spc, flags, false);
2722 0 : for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
2723 : {
2724 : pp_string (pp, ", ");
2725 : dump_generic_node (pp, POLY_INT_CST_COEFF (node, i),
2726 : spc, flags, false);
2727 : }
2728 0 : pp_string (pp, "]");
2729 0 : break;
2730 :
2731 151938 : case REAL_CST:
2732 : /* Code copied from print_node. */
2733 151938 : {
2734 151938 : REAL_VALUE_TYPE d;
2735 151938 : if (TREE_OVERFLOW (node))
2736 0 : pp_string (pp, " overflow");
2737 :
2738 151938 : d = TREE_REAL_CST (node);
2739 151938 : if (REAL_VALUE_ISINF (d))
2740 6550 : pp_string (pp, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
2741 145874 : else if (REAL_VALUE_ISNAN (d))
2742 2285 : pp_string (pp, " Nan");
2743 : else
2744 : {
2745 143589 : char string[100];
2746 143589 : real_to_decimal (string, &d, sizeof (string), 0, 1);
2747 143589 : pp_string (pp, string);
2748 : }
2749 151938 : break;
2750 : }
2751 :
2752 0 : case FIXED_CST:
2753 0 : {
2754 0 : char string[100];
2755 0 : fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
2756 0 : pp_string (pp, string);
2757 0 : break;
2758 : }
2759 :
2760 1554 : case COMPLEX_CST:
2761 1554 : pp_string (pp, "__complex__ (");
2762 1554 : dump_generic_node (pp, TREE_REALPART (node), spc, flags, false);
2763 1554 : pp_string (pp, ", ");
2764 1554 : dump_generic_node (pp, TREE_IMAGPART (node), spc, flags, false);
2765 1554 : pp_right_paren (pp);
2766 1554 : break;
2767 :
2768 62383 : case STRING_CST:
2769 62383 : {
2770 62383 : pp_string (pp, "\"");
2771 62383 : if (unsigned nbytes = TREE_STRING_LENGTH (node))
2772 62140 : pretty_print_string (pp, TREE_STRING_POINTER (node), nbytes);
2773 62383 : pp_string (pp, "\"");
2774 62383 : break;
2775 : }
2776 :
2777 149417 : case VECTOR_CST:
2778 149417 : {
2779 149417 : unsigned i;
2780 149417 : if (flags & TDF_GIMPLE)
2781 : {
2782 0 : pp_string (pp, "_Literal (");
2783 0 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2784 0 : pp_string (pp, ") ");
2785 : }
2786 149417 : pp_string (pp, "{ ");
2787 149417 : unsigned HOST_WIDE_INT nunits;
2788 149417 : if (!VECTOR_CST_NELTS (node).is_constant (&nunits))
2789 : nunits = vector_cst_encoded_nelts (node);
2790 1084406 : for (i = 0; i < nunits; ++i)
2791 : {
2792 934989 : if (i != 0)
2793 785572 : pp_string (pp, ", ");
2794 934989 : dump_generic_node (pp, VECTOR_CST_ELT (node, i),
2795 : spc, flags, false);
2796 : }
2797 149417 : if (!VECTOR_CST_NELTS (node).is_constant ())
2798 : pp_string (pp, ", ...");
2799 149417 : pp_string (pp, " }");
2800 : }
2801 149417 : break;
2802 :
2803 : case RAW_DATA_CST:
2804 36 : for (unsigned i = 0; i < (unsigned) RAW_DATA_LENGTH (node); ++i)
2805 : {
2806 36 : if (TYPE_UNSIGNED (TREE_TYPE (node))
2807 36 : || TYPE_PRECISION (TREE_TYPE (node)) > CHAR_BIT)
2808 36 : pp_decimal_int (pp, RAW_DATA_UCHAR_ELT (node, i));
2809 : else
2810 0 : pp_decimal_int (pp, RAW_DATA_SCHAR_ELT (node, i));
2811 36 : if (i == RAW_DATA_LENGTH (node) - 1U)
2812 : break;
2813 28 : else if (i == 9 && RAW_DATA_LENGTH (node) > 20)
2814 : {
2815 0 : pp_string (pp, ", ..., ");
2816 0 : i = RAW_DATA_LENGTH (node) - 11;
2817 : }
2818 : else
2819 28 : pp_string (pp, ", ");
2820 : }
2821 : break;
2822 :
2823 70 : case FUNCTION_TYPE:
2824 70 : case METHOD_TYPE:
2825 70 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2826 70 : pp_space (pp);
2827 70 : if (TREE_CODE (node) == METHOD_TYPE)
2828 : {
2829 70 : if (TYPE_METHOD_BASETYPE (node))
2830 70 : dump_generic_node (pp, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
2831 : spc, flags, false);
2832 : else
2833 0 : pp_string (pp, "<null method basetype>");
2834 70 : pp_colon_colon (pp);
2835 : }
2836 70 : if (TYPE_IDENTIFIER (node))
2837 0 : dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
2838 70 : else if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
2839 0 : dump_decl_name (pp, TYPE_NAME (node), flags);
2840 70 : else if (flags & TDF_NOUID)
2841 0 : pp_string (pp, "<Txxxx>");
2842 : else
2843 : {
2844 70 : pp_string (pp, "<T");
2845 70 : pp_scalar (pp, "%x", TYPE_UID (node));
2846 70 : pp_character (pp, '>');
2847 : }
2848 70 : dump_function_declaration (pp, node, spc, flags);
2849 70 : break;
2850 :
2851 23762 : case FUNCTION_DECL:
2852 23762 : case CONST_DECL:
2853 23762 : dump_decl_name (pp, node, flags);
2854 23762 : break;
2855 :
2856 125842 : case LABEL_DECL:
2857 125842 : if (DECL_NAME (node))
2858 55001 : dump_decl_name (pp, node, flags);
2859 70841 : else if (LABEL_DECL_UID (node) != -1)
2860 : {
2861 24560 : if (flags & TDF_GIMPLE)
2862 : {
2863 35 : pp_character (pp, 'L');
2864 35 : pp_decimal_int (pp, (int) LABEL_DECL_UID (node));
2865 : }
2866 : else
2867 : {
2868 24525 : pp_string (pp, "<L");
2869 24525 : pp_decimal_int (pp, (int) LABEL_DECL_UID (node));
2870 24525 : pp_character (pp, '>');
2871 : }
2872 : }
2873 : else
2874 : {
2875 46281 : if (flags & TDF_NOUID)
2876 6 : pp_string (pp, "<D.xxxx>");
2877 : else
2878 : {
2879 46275 : if (flags & TDF_GIMPLE)
2880 : {
2881 6 : pp_character (pp, 'D');
2882 6 : pp_scalar (pp, "%u", DECL_UID (node));
2883 : }
2884 : else
2885 : {
2886 46269 : pp_string (pp, "<D.");
2887 46269 : pp_scalar (pp, "%u", DECL_UID (node));
2888 46269 : pp_character (pp, '>');
2889 : }
2890 : }
2891 : }
2892 : break;
2893 :
2894 78000 : case TYPE_DECL:
2895 78000 : if (DECL_IS_UNDECLARED_BUILTIN (node))
2896 : {
2897 : /* Don't print the declaration of built-in types. */
2898 : break;
2899 : }
2900 72814 : if (DECL_NAME (node))
2901 72759 : dump_decl_name (pp, node, flags);
2902 55 : else if (TYPE_NAME (TREE_TYPE (node)) != node)
2903 : {
2904 95 : pp_string (pp, (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
2905 : ? "union" : "struct "));
2906 49 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2907 : }
2908 : else
2909 6 : pp_string (pp, "<anon>");
2910 : break;
2911 :
2912 3738971 : case VAR_DECL:
2913 3738971 : case PARM_DECL:
2914 3738971 : case FIELD_DECL:
2915 3738971 : case DEBUG_EXPR_DECL:
2916 3738971 : case NAMESPACE_DECL:
2917 3738971 : case NAMELIST_DECL:
2918 3738971 : dump_decl_name (pp, node, flags);
2919 3738971 : break;
2920 :
2921 23476 : case RESULT_DECL:
2922 23476 : pp_string (pp, "<retval>");
2923 23476 : break;
2924 :
2925 639222 : case COMPONENT_REF:
2926 639222 : op0 = TREE_OPERAND (node, 0);
2927 639222 : str = ".";
2928 639222 : if (op0
2929 639222 : && (TREE_CODE (op0) == INDIRECT_REF
2930 597745 : || (TREE_CODE (op0) == MEM_REF
2931 197900 : && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR
2932 164893 : && integer_zerop (TREE_OPERAND (op0, 1))
2933 : /* Dump the types of INTEGER_CSTs explicitly, for we
2934 : can't infer them and MEM_ATTR caching will share
2935 : MEM_REFs with differently-typed op0s. */
2936 159555 : && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST
2937 : /* Released SSA_NAMES have no TREE_TYPE. */
2938 159519 : && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE
2939 : /* Same pointer types, but ignoring POINTER_TYPE vs.
2940 : REFERENCE_TYPE. */
2941 159519 : && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
2942 159519 : == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))
2943 307682 : && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0)))
2944 153841 : == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1))))
2945 153841 : && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0)))
2946 153841 : == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1))))
2947 : /* Same value types ignoring qualifiers. */
2948 153841 : && (TYPE_MAIN_VARIANT (TREE_TYPE (op0))
2949 153841 : == TYPE_MAIN_VARIANT
2950 : (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))))
2951 153841 : && MR_DEPENDENCE_CLIQUE (op0) == 0)))
2952 : {
2953 182145 : op0 = TREE_OPERAND (op0, 0);
2954 182145 : str = "->";
2955 : }
2956 639222 : if (op_prio (op0) < op_prio (node))
2957 7105 : pp_left_paren (pp);
2958 639222 : dump_generic_node (pp, op0, spc, flags, false);
2959 639222 : if (op_prio (op0) < op_prio (node))
2960 7105 : pp_right_paren (pp);
2961 639222 : pp_string (pp, str);
2962 639222 : op1 = TREE_OPERAND (node, 1);
2963 639222 : dump_generic_node (pp, op1, spc, flags, false);
2964 639222 : if (DECL_P (op1)) /* Not always a decl in the C++ FE. */
2965 639222 : if (tree off = component_ref_field_offset (node))
2966 639122 : if (TREE_CODE (off) != INTEGER_CST)
2967 : {
2968 16 : pp_string (pp, "{off: ");
2969 16 : dump_generic_node (pp, off, spc, flags, false);
2970 16 : pp_right_brace (pp);
2971 : }
2972 : break;
2973 :
2974 24053 : case BIT_FIELD_REF:
2975 24053 : if (flags & TDF_GIMPLE)
2976 : {
2977 0 : pp_string (pp, "__BIT_FIELD_REF <");
2978 0 : dump_generic_node (pp, TREE_TYPE (node),
2979 : spc, flags | TDF_SLIM, false);
2980 0 : if (TYPE_ALIGN (TREE_TYPE (node))
2981 0 : != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
2982 : {
2983 0 : pp_string (pp, ", ");
2984 0 : pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
2985 : }
2986 0 : pp_greater (pp);
2987 0 : pp_string (pp, " (");
2988 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc,
2989 : flags | TDF_SLIM, false);
2990 0 : pp_string (pp, ", ");
2991 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc,
2992 : flags | TDF_SLIM, false);
2993 0 : pp_string (pp, ", ");
2994 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc,
2995 : flags | TDF_SLIM, false);
2996 0 : pp_right_paren (pp);
2997 : }
2998 : else
2999 : {
3000 24053 : pp_string (pp, "BIT_FIELD_REF <");
3001 24053 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3002 24053 : pp_string (pp, ", ");
3003 24053 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3004 24053 : pp_string (pp, ", ");
3005 24053 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3006 24053 : pp_greater (pp);
3007 : }
3008 : break;
3009 :
3010 0 : case BIT_INSERT_EXPR:
3011 0 : pp_string (pp, "BIT_INSERT_EXPR <");
3012 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3013 0 : pp_string (pp, ", ");
3014 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3015 0 : pp_string (pp, ", ");
3016 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3017 0 : pp_string (pp, " (");
3018 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node, 1))))
3019 0 : pp_decimal_int (pp,
3020 : TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node, 1))));
3021 : else
3022 0 : dump_generic_node (pp, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node, 1))),
3023 : spc, flags, false);
3024 0 : pp_string (pp, " bits)>");
3025 0 : break;
3026 :
3027 2039927 : case ARRAY_REF:
3028 2039927 : case ARRAY_RANGE_REF:
3029 2039927 : op0 = TREE_OPERAND (node, 0);
3030 2039927 : if (op_prio (op0) < op_prio (node))
3031 9617 : pp_left_paren (pp);
3032 2039927 : dump_generic_node (pp, op0, spc, flags, false);
3033 2039927 : if (op_prio (op0) < op_prio (node))
3034 9617 : pp_right_paren (pp);
3035 2039927 : pp_left_bracket (pp);
3036 2039927 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3037 2039927 : if (TREE_CODE (node) == ARRAY_RANGE_REF)
3038 134 : pp_string (pp, " ...");
3039 2039927 : pp_right_bracket (pp);
3040 :
3041 2039927 : op0 = array_ref_low_bound (node);
3042 2039927 : op1 = array_ref_element_size (node);
3043 :
3044 2039927 : if (!integer_zerop (op0)
3045 2018831 : || TREE_OPERAND (node, 2)
3046 4058758 : || TREE_OPERAND (node, 3))
3047 : {
3048 21136 : pp_string (pp, "{lb: ");
3049 21136 : dump_generic_node (pp, op0, spc, flags, false);
3050 21136 : pp_string (pp, " sz: ");
3051 21136 : dump_generic_node (pp, op1, spc, flags, false);
3052 21136 : pp_right_brace (pp);
3053 : }
3054 : break;
3055 :
3056 13 : case OMP_ARRAY_SECTION:
3057 13 : op0 = TREE_OPERAND (node, 0);
3058 13 : if (op_prio (op0) < op_prio (node))
3059 13 : pp_left_paren (pp);
3060 13 : dump_generic_node (pp, op0, spc, flags, false);
3061 13 : if (op_prio (op0) < op_prio (node))
3062 13 : pp_right_paren (pp);
3063 13 : pp_left_bracket (pp);
3064 13 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3065 13 : pp_colon (pp);
3066 13 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3067 13 : pp_right_bracket (pp);
3068 13 : break;
3069 :
3070 59472 : case CONSTRUCTOR:
3071 59472 : {
3072 59472 : unsigned HOST_WIDE_INT ix;
3073 59472 : tree field, val;
3074 59472 : bool is_struct_init = false;
3075 59472 : bool is_array_init = false;
3076 59472 : widest_int curidx;
3077 59472 : if (flags & TDF_GIMPLE)
3078 : {
3079 0 : if (TREE_CLOBBER_P (node))
3080 : {
3081 0 : pp_string (pp, "__CLOBBER");
3082 0 : switch (CLOBBER_KIND (node))
3083 : {
3084 0 : case CLOBBER_STORAGE_BEGIN:
3085 0 : pp_string (pp, "(bos)");
3086 0 : break;
3087 0 : case CLOBBER_STORAGE_END:
3088 0 : pp_string (pp, "(eos)");
3089 0 : break;
3090 0 : case CLOBBER_OBJECT_BEGIN:
3091 0 : pp_string (pp, "(bob)");
3092 0 : break;
3093 0 : case CLOBBER_OBJECT_END:
3094 0 : pp_string (pp, "(eob)");
3095 0 : break;
3096 : default:
3097 : break;
3098 : }
3099 0 : break;
3100 : }
3101 0 : pp_string (pp, "_Literal (");
3102 0 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
3103 0 : pp_string (pp, ") ");
3104 : }
3105 59472 : pp_left_brace (pp);
3106 59472 : if (TREE_CLOBBER_P (node))
3107 : {
3108 23363 : pp_string (pp, "CLOBBER");
3109 23363 : switch (CLOBBER_KIND (node))
3110 : {
3111 0 : case CLOBBER_STORAGE_BEGIN:
3112 0 : pp_string (pp, "(bos)");
3113 0 : break;
3114 15725 : case CLOBBER_STORAGE_END:
3115 15725 : pp_string (pp, "(eos)");
3116 15725 : break;
3117 1285 : case CLOBBER_OBJECT_BEGIN:
3118 1285 : pp_string (pp, "(bob)");
3119 1285 : break;
3120 769 : case CLOBBER_OBJECT_END:
3121 769 : pp_string (pp, "(eob)");
3122 769 : break;
3123 : default:
3124 : break;
3125 : }
3126 : }
3127 36109 : else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
3128 36109 : || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
3129 : is_struct_init = true;
3130 25622 : else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE
3131 6733 : && TYPE_DOMAIN (TREE_TYPE (node))
3132 6733 : && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))
3133 32355 : && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))))
3134 : == INTEGER_CST)
3135 : {
3136 6733 : tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)));
3137 6733 : is_array_init = true;
3138 6733 : curidx = wi::to_widest (minv);
3139 : }
3140 231220 : FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
3141 : {
3142 171748 : if (field)
3143 : {
3144 79733 : if (is_struct_init)
3145 : {
3146 36158 : pp_dot (pp);
3147 36158 : dump_generic_node (pp, field, spc, flags, false);
3148 36158 : pp_equal (pp);
3149 : }
3150 43575 : else if (is_array_init
3151 43575 : && (TREE_CODE (field) != INTEGER_CST
3152 43575 : || curidx != wi::to_widest (field)))
3153 : {
3154 94 : pp_left_bracket (pp);
3155 94 : if (TREE_CODE (field) == RANGE_EXPR)
3156 : {
3157 94 : dump_generic_node (pp, TREE_OPERAND (field, 0), spc,
3158 : flags, false);
3159 94 : pp_string (pp, " ... ");
3160 94 : dump_generic_node (pp, TREE_OPERAND (field, 1), spc,
3161 : flags, false);
3162 94 : if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST)
3163 94 : curidx = wi::to_widest (TREE_OPERAND (field, 1));
3164 : }
3165 : else
3166 0 : dump_generic_node (pp, field, spc, flags, false);
3167 94 : if (TREE_CODE (field) == INTEGER_CST)
3168 0 : curidx = wi::to_widest (field);
3169 94 : pp_string (pp, "]=");
3170 : }
3171 : }
3172 171748 : if (is_array_init)
3173 53373 : curidx += 1;
3174 171748 : if (val && TREE_CODE (val) == ADDR_EXPR)
3175 2640 : if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
3176 146 : val = TREE_OPERAND (val, 0);
3177 171748 : if (val && TREE_CODE (val) == FUNCTION_DECL)
3178 146 : dump_decl_name (pp, val, flags);
3179 : else
3180 171602 : dump_generic_node (pp, val, spc, flags, false);
3181 343496 : if (ix != CONSTRUCTOR_NELTS (node) - 1)
3182 : {
3183 137629 : pp_comma (pp);
3184 137629 : pp_space (pp);
3185 : }
3186 : }
3187 59472 : pp_right_brace (pp);
3188 0 : }
3189 59472 : break;
3190 :
3191 604 : case COMPOUND_EXPR:
3192 604 : {
3193 604 : tree *tp;
3194 604 : if (flags & TDF_SLIM)
3195 : {
3196 0 : pp_string (pp, "<COMPOUND_EXPR>");
3197 0 : break;
3198 : }
3199 :
3200 604 : dump_generic_node (pp, TREE_OPERAND (node, 0),
3201 : spc, flags, false);
3202 604 : pp_comma (pp);
3203 604 : pp_space (pp);
3204 :
3205 604 : for (tp = &TREE_OPERAND (node, 1);
3206 627 : TREE_CODE (*tp) == COMPOUND_EXPR;
3207 23 : tp = &TREE_OPERAND (*tp, 1))
3208 : {
3209 23 : dump_generic_node (pp, TREE_OPERAND (*tp, 0),
3210 : spc, flags, false);
3211 23 : pp_comma (pp);
3212 23 : pp_space (pp);
3213 : }
3214 :
3215 604 : dump_generic_node (pp, *tp, spc, flags, false);
3216 : }
3217 604 : break;
3218 :
3219 66195 : case STATEMENT_LIST:
3220 66195 : {
3221 66195 : tree_stmt_iterator si;
3222 66195 : bool first = true;
3223 :
3224 66195 : if (flags & TDF_SLIM)
3225 : {
3226 1 : pp_string (pp, "<STATEMENT_LIST>");
3227 1 : break;
3228 : }
3229 :
3230 436335 : for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
3231 : {
3232 370141 : if (!first)
3233 304681 : newline_and_indent (pp, spc);
3234 : else
3235 : first = false;
3236 370141 : dump_generic_node (pp, tsi_stmt (si), spc, flags, true);
3237 : }
3238 : }
3239 66194 : break;
3240 :
3241 212361 : case MODIFY_EXPR:
3242 212361 : case INIT_EXPR:
3243 212361 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags,
3244 : false);
3245 212361 : pp_space (pp);
3246 212361 : pp_equal (pp);
3247 212361 : pp_space (pp);
3248 212361 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags,
3249 : false);
3250 212361 : break;
3251 :
3252 2187 : case TARGET_EXPR:
3253 2187 : pp_string (pp, "TARGET_EXPR <");
3254 2187 : dump_generic_node (pp, TARGET_EXPR_SLOT (node), spc, flags, false);
3255 2187 : pp_comma (pp);
3256 2187 : pp_space (pp);
3257 2187 : dump_generic_node (pp, TARGET_EXPR_INITIAL (node), spc, flags, false);
3258 2187 : pp_greater (pp);
3259 2187 : break;
3260 :
3261 12293 : case DECL_EXPR:
3262 12293 : print_declaration (pp, DECL_EXPR_DECL (node), spc, flags);
3263 12293 : is_stmt = false;
3264 12293 : break;
3265 :
3266 49094 : case COND_EXPR:
3267 49094 : if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
3268 : {
3269 44288 : pp_string (pp, "if (");
3270 44288 : dump_generic_node (pp, COND_EXPR_COND (node), spc, flags, false);
3271 44288 : pp_right_paren (pp);
3272 : /* The lowered cond_exprs should always be printed in full. */
3273 44288 : if (COND_EXPR_THEN (node)
3274 44288 : && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
3275 43412 : || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
3276 16086 : && COND_EXPR_ELSE (node)
3277 60373 : && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
3278 2384 : || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
3279 : {
3280 15195 : pp_space (pp);
3281 15195 : dump_generic_node (pp, COND_EXPR_THEN (node),
3282 : 0, flags, true);
3283 15195 : if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
3284 : {
3285 1494 : pp_string (pp, " else ");
3286 1494 : dump_generic_node (pp, COND_EXPR_ELSE (node),
3287 : 0, flags, true);
3288 : }
3289 : }
3290 29093 : else if (!(flags & TDF_SLIM))
3291 : {
3292 : /* Output COND_EXPR_THEN. */
3293 29093 : if (COND_EXPR_THEN (node))
3294 : {
3295 29093 : newline_and_indent (pp, spc+2);
3296 29093 : pp_left_brace (pp);
3297 29093 : newline_and_indent (pp, spc+4);
3298 29093 : dump_generic_node (pp, COND_EXPR_THEN (node), spc+4,
3299 : flags, true);
3300 29093 : newline_and_indent (pp, spc+2);
3301 29093 : pp_right_brace (pp);
3302 : }
3303 :
3304 : /* Output COND_EXPR_ELSE. */
3305 29093 : if (COND_EXPR_ELSE (node)
3306 29093 : && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
3307 : {
3308 8096 : newline_and_indent (pp, spc);
3309 8096 : pp_string (pp, "else");
3310 8096 : newline_and_indent (pp, spc+2);
3311 8096 : pp_left_brace (pp);
3312 8096 : newline_and_indent (pp, spc+4);
3313 8096 : dump_generic_node (pp, COND_EXPR_ELSE (node), spc+4,
3314 : flags, true);
3315 8096 : newline_and_indent (pp, spc+2);
3316 8096 : pp_right_brace (pp);
3317 : }
3318 : }
3319 : is_expr = false;
3320 : }
3321 : else
3322 : {
3323 4806 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3324 4806 : pp_space (pp);
3325 4806 : pp_question (pp);
3326 4806 : pp_space (pp);
3327 4806 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3328 4806 : pp_space (pp);
3329 4806 : pp_colon (pp);
3330 4806 : pp_space (pp);
3331 4806 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3332 : }
3333 : break;
3334 :
3335 43411 : case BIND_EXPR:
3336 43411 : pp_left_brace (pp);
3337 43411 : if (!(flags & TDF_SLIM))
3338 : {
3339 43411 : if (BIND_EXPR_VARS (node))
3340 : {
3341 35533 : pp_newline (pp);
3342 :
3343 152084 : for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0))
3344 : {
3345 116551 : print_declaration (pp, op0, spc+2, flags);
3346 116551 : pp_newline (pp);
3347 : }
3348 : }
3349 :
3350 43411 : newline_and_indent (pp, spc+2);
3351 43411 : dump_generic_node (pp, BIND_EXPR_BODY (node), spc+2, flags, true);
3352 43411 : newline_and_indent (pp, spc);
3353 43411 : pp_right_brace (pp);
3354 : }
3355 : is_expr = false;
3356 : break;
3357 :
3358 66804 : case CALL_EXPR:
3359 66804 : if (CALL_EXPR_FN (node) != NULL_TREE)
3360 66650 : print_call_name (pp, CALL_EXPR_FN (node), flags);
3361 : else
3362 : {
3363 154 : pp_dot (pp);
3364 154 : pp_string (pp, internal_fn_name (CALL_EXPR_IFN (node)));
3365 : }
3366 :
3367 : /* Print parameters. */
3368 66804 : pp_space (pp);
3369 66804 : pp_left_paren (pp);
3370 66804 : {
3371 66804 : tree arg;
3372 66804 : call_expr_arg_iterator iter;
3373 256647 : FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
3374 : {
3375 123039 : dump_generic_node (pp, arg, spc, flags, false);
3376 123039 : if (more_call_expr_args_p (&iter))
3377 : {
3378 63577 : pp_comma (pp);
3379 63577 : pp_space (pp);
3380 : }
3381 : }
3382 : }
3383 66804 : if (CALL_EXPR_VA_ARG_PACK (node))
3384 : {
3385 0 : if (call_expr_nargs (node) > 0)
3386 : {
3387 0 : pp_comma (pp);
3388 0 : pp_space (pp);
3389 : }
3390 0 : pp_string (pp, "__builtin_va_arg_pack ()");
3391 : }
3392 66804 : pp_right_paren (pp);
3393 :
3394 66804 : op1 = CALL_EXPR_STATIC_CHAIN (node);
3395 66804 : if (op1)
3396 : {
3397 0 : pp_string (pp, " [static-chain: ");
3398 0 : dump_generic_node (pp, op1, spc, flags, false);
3399 0 : pp_right_bracket (pp);
3400 : }
3401 :
3402 66804 : if (CALL_EXPR_RETURN_SLOT_OPT (node))
3403 0 : pp_string (pp, " [return slot optimization]");
3404 66804 : if (CALL_EXPR_TAILCALL (node))
3405 0 : pp_string (pp, " [tail call]");
3406 66804 : if (CALL_EXPR_MUST_TAIL_CALL (node))
3407 0 : pp_string (pp, " [must tail call]");
3408 : break;
3409 :
3410 0 : case WITH_CLEANUP_EXPR:
3411 0 : NIY;
3412 0 : break;
3413 :
3414 16913 : case CLEANUP_POINT_EXPR:
3415 16913 : pp_string (pp, "<<cleanup_point ");
3416 16913 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3417 16913 : pp_string (pp, ">>");
3418 16913 : break;
3419 :
3420 0 : case PLACEHOLDER_EXPR:
3421 0 : pp_string (pp, "<PLACEHOLDER_EXPR ");
3422 0 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
3423 0 : pp_greater (pp);
3424 0 : break;
3425 :
3426 : /* Binary arithmetic and logic expressions. */
3427 261086 : case WIDEN_SUM_EXPR:
3428 261086 : case WIDEN_MULT_EXPR:
3429 261086 : case MULT_EXPR:
3430 261086 : case MULT_HIGHPART_EXPR:
3431 261086 : case PLUS_EXPR:
3432 261086 : case POINTER_PLUS_EXPR:
3433 261086 : case POINTER_DIFF_EXPR:
3434 261086 : case MINUS_EXPR:
3435 261086 : case TRUNC_DIV_EXPR:
3436 261086 : case CEIL_DIV_EXPR:
3437 261086 : case FLOOR_DIV_EXPR:
3438 261086 : case ROUND_DIV_EXPR:
3439 261086 : case TRUNC_MOD_EXPR:
3440 261086 : case CEIL_MOD_EXPR:
3441 261086 : case FLOOR_MOD_EXPR:
3442 261086 : case ROUND_MOD_EXPR:
3443 261086 : case RDIV_EXPR:
3444 261086 : case EXACT_DIV_EXPR:
3445 261086 : case LSHIFT_EXPR:
3446 261086 : case RSHIFT_EXPR:
3447 261086 : case LROTATE_EXPR:
3448 261086 : case RROTATE_EXPR:
3449 261086 : case WIDEN_LSHIFT_EXPR:
3450 261086 : case BIT_IOR_EXPR:
3451 261086 : case BIT_XOR_EXPR:
3452 261086 : case BIT_AND_EXPR:
3453 261086 : case TRUTH_ANDIF_EXPR:
3454 261086 : case TRUTH_ORIF_EXPR:
3455 261086 : case TRUTH_AND_EXPR:
3456 261086 : case TRUTH_OR_EXPR:
3457 261086 : case TRUTH_XOR_EXPR:
3458 261086 : case LT_EXPR:
3459 261086 : case LE_EXPR:
3460 261086 : case GT_EXPR:
3461 261086 : case GE_EXPR:
3462 261086 : case EQ_EXPR:
3463 261086 : case NE_EXPR:
3464 261086 : case UNLT_EXPR:
3465 261086 : case UNLE_EXPR:
3466 261086 : case UNGT_EXPR:
3467 261086 : case UNGE_EXPR:
3468 261086 : case UNEQ_EXPR:
3469 261086 : case LTGT_EXPR:
3470 261086 : case ORDERED_EXPR:
3471 261086 : case UNORDERED_EXPR:
3472 261086 : {
3473 522172 : const char *op = op_symbol (node);
3474 261086 : op0 = TREE_OPERAND (node, 0);
3475 261086 : op1 = TREE_OPERAND (node, 1);
3476 :
3477 : /* When the operands are expressions with less priority,
3478 : keep semantics of the tree representation. */
3479 261086 : if (op_prio (op0) <= op_prio (node))
3480 : {
3481 35517 : pp_left_paren (pp);
3482 35517 : dump_generic_node (pp, op0, spc, flags, false);
3483 35517 : pp_right_paren (pp);
3484 : }
3485 : else
3486 225569 : dump_generic_node (pp, op0, spc, flags, false);
3487 :
3488 261086 : pp_space (pp);
3489 261086 : pp_string (pp, op);
3490 261086 : pp_space (pp);
3491 :
3492 : /* When the operands are expressions with less priority,
3493 : keep semantics of the tree representation. */
3494 261086 : if (op_prio (op1) <= op_prio (node))
3495 : {
3496 3118 : pp_left_paren (pp);
3497 3118 : dump_generic_node (pp, op1, spc, flags, false);
3498 3118 : pp_right_paren (pp);
3499 : }
3500 : else
3501 257968 : dump_generic_node (pp, op1, spc, flags, false);
3502 : }
3503 : break;
3504 :
3505 : /* Unary arithmetic and logic expressions. */
3506 330521 : case ADDR_EXPR:
3507 330521 : if (flags & TDF_GIMPLE_VAL)
3508 : {
3509 0 : pp_string (pp, "_Literal (");
3510 0 : dump_generic_node (pp, TREE_TYPE (node), spc,
3511 : flags & ~TDF_GIMPLE_VAL, false);
3512 0 : pp_character (pp, ')');
3513 : }
3514 : /* Fallthru. */
3515 358112 : case NEGATE_EXPR:
3516 358112 : case BIT_NOT_EXPR:
3517 358112 : case TRUTH_NOT_EXPR:
3518 358112 : case PREDECREMENT_EXPR:
3519 358112 : case PREINCREMENT_EXPR:
3520 358112 : case INDIRECT_REF:
3521 358112 : if (!(flags & TDF_GIMPLE)
3522 358112 : && TREE_CODE (node) == ADDR_EXPR
3523 688633 : && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
3524 323868 : || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
3525 : /* Do not output '&' for strings and function pointers when not
3526 : dumping GIMPLE FE syntax. */
3527 : ;
3528 : else
3529 341493 : pp_string (pp, op_symbol (node));
3530 :
3531 358112 : if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
3532 : {
3533 4086 : pp_left_paren (pp);
3534 4086 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3535 4086 : pp_right_paren (pp);
3536 : }
3537 : else
3538 354026 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3539 : break;
3540 :
3541 1535 : case POSTDECREMENT_EXPR:
3542 1535 : case POSTINCREMENT_EXPR:
3543 1535 : if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
3544 : {
3545 0 : pp_left_paren (pp);
3546 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3547 0 : pp_right_paren (pp);
3548 : }
3549 : else
3550 1535 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3551 3070 : pp_string (pp, op_symbol (node));
3552 1535 : break;
3553 :
3554 368 : case MIN_EXPR:
3555 368 : pp_string (pp, "MIN_EXPR <");
3556 368 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3557 368 : pp_string (pp, ", ");
3558 368 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3559 368 : pp_greater (pp);
3560 368 : break;
3561 :
3562 6096 : case MAX_EXPR:
3563 6096 : pp_string (pp, "MAX_EXPR <");
3564 6096 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3565 6096 : pp_string (pp, ", ");
3566 6096 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3567 6096 : pp_greater (pp);
3568 6096 : break;
3569 :
3570 529 : case ABS_EXPR:
3571 529 : pp_string (pp, "ABS_EXPR <");
3572 529 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3573 529 : pp_greater (pp);
3574 529 : break;
3575 :
3576 24 : case ABSU_EXPR:
3577 24 : pp_string (pp, "ABSU_EXPR <");
3578 24 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3579 24 : pp_greater (pp);
3580 24 : break;
3581 :
3582 0 : case RANGE_EXPR:
3583 0 : NIY;
3584 0 : break;
3585 :
3586 181185 : case ADDR_SPACE_CONVERT_EXPR:
3587 181185 : case FIXED_CONVERT_EXPR:
3588 181185 : case FIX_TRUNC_EXPR:
3589 181185 : case FLOAT_EXPR:
3590 181185 : CASE_CONVERT:
3591 181185 : type = TREE_TYPE (node);
3592 181185 : op0 = TREE_OPERAND (node, 0);
3593 181185 : if (type != TREE_TYPE (op0))
3594 : {
3595 181163 : pp_left_paren (pp);
3596 181163 : dump_generic_node (pp, type, spc, flags, false);
3597 181163 : pp_string (pp, ") ");
3598 : }
3599 181185 : if (op_prio (op0) < op_prio (node))
3600 38912 : pp_left_paren (pp);
3601 181185 : dump_generic_node (pp, op0, spc, flags, false);
3602 181185 : if (op_prio (op0) < op_prio (node))
3603 38912 : pp_right_paren (pp);
3604 : break;
3605 :
3606 38453 : case VIEW_CONVERT_EXPR:
3607 38453 : if (flags & TDF_GIMPLE)
3608 0 : pp_string (pp, "__VIEW_CONVERT <");
3609 : else
3610 38453 : pp_string (pp, "VIEW_CONVERT_EXPR<");
3611 38453 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
3612 38453 : pp_string (pp, ">(");
3613 38453 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3614 38453 : pp_right_paren (pp);
3615 38453 : break;
3616 :
3617 14 : case PAREN_EXPR:
3618 14 : pp_string (pp, "((");
3619 14 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3620 14 : pp_string (pp, "))");
3621 14 : break;
3622 :
3623 17398 : case NON_LVALUE_EXPR:
3624 17398 : pp_string (pp, "NON_LVALUE_EXPR <");
3625 17398 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3626 17398 : pp_greater (pp);
3627 17398 : break;
3628 :
3629 1582 : case SAVE_EXPR:
3630 1582 : pp_string (pp, "SAVE_EXPR <");
3631 1582 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3632 1582 : pp_greater (pp);
3633 1582 : break;
3634 :
3635 26 : case COMPLEX_EXPR:
3636 26 : pp_string (pp, "COMPLEX_EXPR <");
3637 26 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3638 26 : pp_string (pp, ", ");
3639 26 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3640 26 : pp_greater (pp);
3641 26 : break;
3642 :
3643 0 : case CONJ_EXPR:
3644 0 : pp_string (pp, "CONJ_EXPR <");
3645 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3646 0 : pp_greater (pp);
3647 0 : break;
3648 :
3649 51194 : case REALPART_EXPR:
3650 51194 : if (flags & TDF_GIMPLE)
3651 : {
3652 1 : pp_string (pp, "__real ");
3653 1 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3654 : }
3655 : else
3656 : {
3657 51193 : pp_string (pp, "REALPART_EXPR <");
3658 51193 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3659 51193 : pp_greater (pp);
3660 : }
3661 : break;
3662 :
3663 41376 : case IMAGPART_EXPR:
3664 41376 : if (flags & TDF_GIMPLE)
3665 : {
3666 1 : pp_string (pp, "__imag ");
3667 1 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3668 : }
3669 : else
3670 : {
3671 41375 : pp_string (pp, "IMAGPART_EXPR <");
3672 41375 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3673 41375 : pp_greater (pp);
3674 : }
3675 : break;
3676 :
3677 0 : case VA_ARG_EXPR:
3678 0 : pp_string (pp, "VA_ARG_EXPR <");
3679 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3680 0 : pp_greater (pp);
3681 0 : break;
3682 :
3683 1618 : case TRY_FINALLY_EXPR:
3684 1618 : case TRY_CATCH_EXPR:
3685 1618 : pp_string (pp, "try");
3686 1618 : newline_and_indent (pp, spc+2);
3687 1618 : pp_left_brace (pp);
3688 1618 : newline_and_indent (pp, spc+4);
3689 1618 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, flags, true);
3690 1618 : newline_and_indent (pp, spc+2);
3691 1618 : pp_right_brace (pp);
3692 1618 : newline_and_indent (pp, spc);
3693 1618 : if (TREE_CODE (node) == TRY_CATCH_EXPR)
3694 : {
3695 79 : node = TREE_OPERAND (node, 1);
3696 79 : pp_string (pp, "catch");
3697 : }
3698 : else
3699 : {
3700 1539 : gcc_assert (TREE_CODE (node) == TRY_FINALLY_EXPR);
3701 1539 : node = TREE_OPERAND (node, 1);
3702 1539 : pp_string (pp, "finally");
3703 1539 : if (TREE_CODE (node) == EH_ELSE_EXPR)
3704 : {
3705 0 : newline_and_indent (pp, spc+2);
3706 0 : pp_left_brace (pp);
3707 0 : newline_and_indent (pp, spc+4);
3708 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4,
3709 : flags, true);
3710 0 : newline_and_indent (pp, spc+2);
3711 0 : pp_right_brace (pp);
3712 0 : newline_and_indent (pp, spc);
3713 0 : node = TREE_OPERAND (node, 1);
3714 0 : pp_string (pp, "else");
3715 : }
3716 : }
3717 1618 : newline_and_indent (pp, spc+2);
3718 1618 : pp_left_brace (pp);
3719 1618 : newline_and_indent (pp, spc+4);
3720 1618 : dump_generic_node (pp, node, spc+4, flags, true);
3721 1618 : newline_and_indent (pp, spc+2);
3722 1618 : pp_right_brace (pp);
3723 1618 : is_expr = false;
3724 1618 : break;
3725 :
3726 0 : case CATCH_EXPR:
3727 0 : pp_string (pp, "catch (");
3728 0 : dump_generic_node (pp, CATCH_TYPES (node), spc+2, flags, false);
3729 0 : pp_right_paren (pp);
3730 0 : newline_and_indent (pp, spc+2);
3731 0 : pp_left_brace (pp);
3732 0 : newline_and_indent (pp, spc+4);
3733 0 : dump_generic_node (pp, CATCH_BODY (node), spc+4, flags, true);
3734 0 : newline_and_indent (pp, spc+2);
3735 0 : pp_right_brace (pp);
3736 0 : is_expr = false;
3737 0 : break;
3738 :
3739 0 : case EH_FILTER_EXPR:
3740 0 : pp_string (pp, "<<<eh_filter (");
3741 0 : dump_generic_node (pp, EH_FILTER_TYPES (node), spc+2, flags, false);
3742 0 : pp_string (pp, ")>>>");
3743 0 : newline_and_indent (pp, spc+2);
3744 0 : pp_left_brace (pp);
3745 0 : newline_and_indent (pp, spc+4);
3746 0 : dump_generic_node (pp, EH_FILTER_FAILURE (node), spc+4, flags, true);
3747 0 : newline_and_indent (pp, spc+2);
3748 0 : pp_right_brace (pp);
3749 0 : is_expr = false;
3750 0 : break;
3751 :
3752 33221 : case LABEL_EXPR:
3753 33221 : op0 = TREE_OPERAND (node, 0);
3754 : /* If this is for break or continue, don't bother printing it. */
3755 33221 : if (DECL_NAME (op0))
3756 : {
3757 28708 : const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
3758 28708 : if (strcmp (name, "break") == 0
3759 28708 : || strcmp (name, "continue") == 0)
3760 : break;
3761 : }
3762 33221 : dump_generic_node (pp, op0, spc, flags, false);
3763 33221 : pp_colon (pp);
3764 33221 : if (DECL_NONLOCAL (op0))
3765 0 : pp_string (pp, " [non-local]");
3766 : break;
3767 :
3768 10671 : case LOOP_EXPR:
3769 10671 : pp_string (pp, "while (1)");
3770 10671 : if (!(flags & TDF_SLIM))
3771 : {
3772 10671 : newline_and_indent (pp, spc+2);
3773 10671 : pp_left_brace (pp);
3774 10671 : newline_and_indent (pp, spc+4);
3775 10671 : dump_generic_node (pp, LOOP_EXPR_BODY (node), spc+4, flags, true);
3776 10671 : newline_and_indent (pp, spc+2);
3777 10671 : pp_right_brace (pp);
3778 : }
3779 : is_expr = false;
3780 : break;
3781 :
3782 26 : case PREDICT_EXPR:
3783 26 : pp_string (pp, "// predicted ");
3784 26 : if (PREDICT_EXPR_OUTCOME (node))
3785 7 : pp_string (pp, "likely by ");
3786 : else
3787 19 : pp_string (pp, "unlikely by ");
3788 26 : pp_string (pp, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
3789 26 : pp_string (pp, " predictor.");
3790 26 : break;
3791 :
3792 52 : case ANNOTATE_EXPR:
3793 52 : pp_string (pp, "ANNOTATE_EXPR <");
3794 52 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3795 52 : switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1)))
3796 : {
3797 44 : case annot_expr_ivdep_kind:
3798 44 : pp_string (pp, ", ivdep");
3799 44 : break;
3800 2 : case annot_expr_unroll_kind:
3801 2 : {
3802 2 : pp_string (pp, ", unroll ");
3803 2 : pp_decimal_int (pp,
3804 : (int) TREE_INT_CST_LOW (TREE_OPERAND (node, 2)));
3805 2 : break;
3806 : }
3807 3 : case annot_expr_no_vector_kind:
3808 3 : pp_string (pp, ", no-vector");
3809 3 : break;
3810 3 : case annot_expr_vector_kind:
3811 3 : pp_string (pp, ", vector");
3812 3 : break;
3813 0 : case annot_expr_parallel_kind:
3814 0 : pp_string (pp, ", parallel");
3815 0 : break;
3816 0 : case annot_expr_maybe_infinite_kind:
3817 0 : pp_string (pp, ", maybe-infinite");
3818 0 : break;
3819 0 : default:
3820 0 : gcc_unreachable ();
3821 : }
3822 52 : pp_greater (pp);
3823 52 : break;
3824 :
3825 9797 : case RETURN_EXPR:
3826 9797 : pp_string (pp, "return");
3827 9797 : op0 = TREE_OPERAND (node, 0);
3828 9797 : if (op0)
3829 : {
3830 9610 : pp_space (pp);
3831 9610 : if (TREE_CODE (op0) == MODIFY_EXPR)
3832 2840 : dump_generic_node (pp, TREE_OPERAND (op0, 1),
3833 : spc, flags, false);
3834 : else
3835 6770 : dump_generic_node (pp, op0, spc, flags, false);
3836 : }
3837 : break;
3838 :
3839 0 : case EXIT_EXPR:
3840 0 : pp_string (pp, "if (");
3841 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3842 0 : pp_string (pp, ") break");
3843 0 : break;
3844 :
3845 66 : case SWITCH_EXPR:
3846 66 : pp_string (pp, "switch (");
3847 66 : dump_generic_node (pp, SWITCH_COND (node), spc, flags, false);
3848 66 : pp_right_paren (pp);
3849 66 : if (!(flags & TDF_SLIM))
3850 : {
3851 66 : newline_and_indent (pp, spc+2);
3852 66 : pp_left_brace (pp);
3853 66 : if (SWITCH_BODY (node))
3854 : {
3855 66 : newline_and_indent (pp, spc+4);
3856 66 : dump_generic_node (pp, SWITCH_BODY (node), spc+4, flags,
3857 : true);
3858 : }
3859 66 : newline_and_indent (pp, spc+2);
3860 66 : pp_right_brace (pp);
3861 : }
3862 : is_expr = false;
3863 : break;
3864 :
3865 22823 : case GOTO_EXPR:
3866 22823 : op0 = GOTO_DESTINATION (node);
3867 22823 : if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
3868 : {
3869 18038 : const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
3870 18038 : if (strcmp (name, "break") == 0
3871 18038 : || strcmp (name, "continue") == 0)
3872 : {
3873 0 : pp_string (pp, name);
3874 0 : break;
3875 : }
3876 : }
3877 22823 : pp_string (pp, "goto ");
3878 22823 : dump_generic_node (pp, op0, spc, flags, false);
3879 22823 : break;
3880 :
3881 292 : case ASM_EXPR:
3882 292 : pp_string (pp, "__asm__");
3883 292 : if (ASM_VOLATILE_P (node))
3884 292 : pp_string (pp, " __volatile__");
3885 292 : pp_left_paren (pp);
3886 292 : dump_generic_node (pp, ASM_STRING (node), spc, flags, false);
3887 292 : pp_colon (pp);
3888 292 : dump_generic_node (pp, ASM_OUTPUTS (node), spc, flags, false);
3889 292 : pp_colon (pp);
3890 292 : dump_generic_node (pp, ASM_INPUTS (node), spc, flags, false);
3891 292 : if (ASM_CLOBBERS (node))
3892 : {
3893 292 : pp_colon (pp);
3894 292 : dump_generic_node (pp, ASM_CLOBBERS (node), spc, flags, false);
3895 : }
3896 292 : pp_right_paren (pp);
3897 292 : break;
3898 :
3899 8975 : case CASE_LABEL_EXPR:
3900 8975 : if (CASE_LOW (node) && CASE_HIGH (node))
3901 : {
3902 121 : pp_string (pp, "case ");
3903 121 : dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
3904 121 : pp_string (pp, " ... ");
3905 121 : dump_generic_node (pp, CASE_HIGH (node), spc, flags, false);
3906 : }
3907 8854 : else if (CASE_LOW (node))
3908 : {
3909 7312 : pp_string (pp, "case ");
3910 7312 : dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
3911 : }
3912 : else
3913 1542 : pp_string (pp, "default");
3914 8975 : pp_colon (pp);
3915 8975 : break;
3916 :
3917 1782 : case OBJ_TYPE_REF:
3918 1782 : pp_string (pp, "OBJ_TYPE_REF(");
3919 1782 : dump_generic_node (pp, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
3920 1782 : pp_semicolon (pp);
3921 : /* We omit the class type for -fcompare-debug because we may
3922 : drop TYPE_BINFO early depending on debug info, and then
3923 : virtual_method_call_p would return false, whereas when
3924 : TYPE_BINFO is preserved it may still return true and then
3925 : we'd print the class type. Compare tree and rtl dumps for
3926 : libstdc++-prettyprinters/shared_ptr.cc with and without -g,
3927 : for example, at occurrences of OBJ_TYPE_REF. */
3928 1782 : if (!(flags & (TDF_SLIM | TDF_COMPARE_DEBUG))
3929 1782 : && virtual_method_call_p (node, true))
3930 : {
3931 1479 : pp_string (pp, "(");
3932 1479 : dump_generic_node (pp, obj_type_ref_class (node, true),
3933 : spc, flags, false);
3934 1479 : pp_string (pp, ")");
3935 : }
3936 1782 : dump_generic_node (pp, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
3937 1782 : pp_arrow (pp);
3938 1782 : dump_generic_node (pp, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
3939 1782 : pp_right_paren (pp);
3940 1782 : break;
3941 :
3942 17709474 : case SSA_NAME:
3943 17709474 : if (SSA_NAME_IDENTIFIER (node))
3944 : {
3945 10167682 : if ((flags & TDF_NOUID)
3946 7613 : && SSA_NAME_VAR (node)
3947 10172422 : && DECL_NAMELESS (SSA_NAME_VAR (node)))
3948 1202 : dump_fancy_name (pp, SSA_NAME_IDENTIFIER (node));
3949 10166480 : else if (! (flags & TDF_GIMPLE)
3950 10166480 : || SSA_NAME_VAR (node))
3951 10166480 : dump_generic_node (pp, SSA_NAME_IDENTIFIER (node),
3952 : spc, flags, false);
3953 : }
3954 17709474 : pp_underscore (pp);
3955 17709474 : pp_decimal_int (pp, SSA_NAME_VERSION (node));
3956 17709474 : if (SSA_NAME_IS_DEFAULT_DEF (node))
3957 723562 : pp_string (pp, "(D)");
3958 17709474 : if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
3959 578 : pp_string (pp, "(ab)");
3960 : break;
3961 :
3962 0 : case WITH_SIZE_EXPR:
3963 0 : pp_string (pp, "WITH_SIZE_EXPR <");
3964 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3965 0 : pp_string (pp, ", ");
3966 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3967 0 : pp_greater (pp);
3968 0 : break;
3969 :
3970 0 : case SCEV_KNOWN:
3971 0 : pp_string (pp, "scev_known");
3972 0 : break;
3973 :
3974 4803 : case SCEV_NOT_KNOWN:
3975 4803 : pp_string (pp, "scev_not_known");
3976 4803 : break;
3977 :
3978 151160 : case POLYNOMIAL_CHREC:
3979 151160 : pp_left_brace (pp);
3980 151160 : dump_generic_node (pp, CHREC_LEFT (node), spc, flags, false);
3981 151160 : pp_string (pp, ", +, ");
3982 151160 : dump_generic_node (pp, CHREC_RIGHT (node), spc, flags, false);
3983 160007 : pp_string (pp, !CHREC_NOWRAP (node) ? "}_" : "}<nw>_");
3984 151160 : pp_scalar (pp, "%u", CHREC_VARIABLE (node));
3985 151160 : is_stmt = false;
3986 151160 : break;
3987 :
3988 0 : case REALIGN_LOAD_EXPR:
3989 0 : pp_string (pp, "REALIGN_LOAD <");
3990 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3991 0 : pp_string (pp, ", ");
3992 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3993 0 : pp_string (pp, ", ");
3994 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3995 0 : pp_greater (pp);
3996 0 : break;
3997 :
3998 0 : case VEC_COND_EXPR:
3999 0 : pp_string (pp, " VEC_COND_EXPR < ");
4000 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4001 0 : pp_string (pp, " , ");
4002 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4003 0 : pp_string (pp, " , ");
4004 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
4005 0 : pp_string (pp, " > ");
4006 0 : break;
4007 :
4008 0 : case VEC_PERM_EXPR:
4009 0 : pp_string (pp, " VEC_PERM_EXPR < ");
4010 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4011 0 : pp_string (pp, " , ");
4012 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4013 0 : pp_string (pp, " , ");
4014 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
4015 0 : pp_string (pp, " > ");
4016 0 : break;
4017 :
4018 0 : case DOT_PROD_EXPR:
4019 0 : pp_string (pp, " DOT_PROD_EXPR < ");
4020 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4021 0 : pp_string (pp, ", ");
4022 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4023 0 : pp_string (pp, ", ");
4024 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
4025 0 : pp_string (pp, " > ");
4026 0 : break;
4027 :
4028 0 : case WIDEN_MULT_PLUS_EXPR:
4029 0 : pp_string (pp, " WIDEN_MULT_PLUS_EXPR < ");
4030 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4031 0 : pp_string (pp, ", ");
4032 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4033 0 : pp_string (pp, ", ");
4034 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
4035 0 : pp_string (pp, " > ");
4036 0 : break;
4037 :
4038 0 : case WIDEN_MULT_MINUS_EXPR:
4039 0 : pp_string (pp, " WIDEN_MULT_MINUS_EXPR < ");
4040 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4041 0 : pp_string (pp, ", ");
4042 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4043 0 : pp_string (pp, ", ");
4044 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
4045 0 : pp_string (pp, " > ");
4046 0 : break;
4047 :
4048 117 : case OACC_PARALLEL:
4049 117 : pp_string (pp, "#pragma acc parallel");
4050 117 : goto dump_omp_clauses_body;
4051 :
4052 57 : case OACC_KERNELS:
4053 57 : pp_string (pp, "#pragma acc kernels");
4054 57 : goto dump_omp_clauses_body;
4055 :
4056 58 : case OACC_SERIAL:
4057 58 : pp_string (pp, "#pragma acc serial");
4058 58 : goto dump_omp_clauses_body;
4059 :
4060 21 : case OACC_DATA:
4061 21 : pp_string (pp, "#pragma acc data");
4062 21 : dump_omp_clauses (pp, OACC_DATA_CLAUSES (node), spc, flags);
4063 21 : goto dump_omp_body;
4064 :
4065 35 : case OACC_HOST_DATA:
4066 35 : pp_string (pp, "#pragma acc host_data");
4067 35 : dump_omp_clauses (pp, OACC_HOST_DATA_CLAUSES (node), spc, flags);
4068 35 : goto dump_omp_body;
4069 :
4070 4 : case OACC_DECLARE:
4071 4 : pp_string (pp, "#pragma acc declare");
4072 4 : dump_omp_clauses (pp, OACC_DECLARE_CLAUSES (node), spc, flags);
4073 4 : break;
4074 :
4075 0 : case OACC_UPDATE:
4076 0 : pp_string (pp, "#pragma acc update");
4077 0 : dump_omp_clauses (pp, OACC_UPDATE_CLAUSES (node), spc, flags);
4078 0 : break;
4079 :
4080 13 : case OACC_ENTER_DATA:
4081 13 : pp_string (pp, "#pragma acc enter data");
4082 13 : dump_omp_clauses (pp, OACC_ENTER_DATA_CLAUSES (node), spc, flags);
4083 13 : break;
4084 :
4085 38 : case OACC_EXIT_DATA:
4086 38 : pp_string (pp, "#pragma acc exit data");
4087 38 : dump_omp_clauses (pp, OACC_EXIT_DATA_CLAUSES (node), spc, flags);
4088 38 : break;
4089 :
4090 48 : case OACC_CACHE:
4091 48 : pp_string (pp, "#pragma acc cache");
4092 48 : dump_omp_clauses (pp, OACC_CACHE_CLAUSES (node), spc, flags);
4093 48 : break;
4094 :
4095 230 : case OMP_PARALLEL:
4096 230 : pp_string (pp, "#pragma omp parallel");
4097 230 : dump_omp_clauses (pp, OMP_PARALLEL_CLAUSES (node), spc, flags);
4098 230 : goto dump_omp_body;
4099 :
4100 232 : dump_omp_clauses_body:
4101 232 : dump_omp_clauses (pp, OMP_CLAUSES (node), spc, flags);
4102 232 : goto dump_omp_body;
4103 :
4104 1542 : dump_omp_body:
4105 1542 : if (!(flags & TDF_SLIM) && OMP_BODY (node))
4106 : {
4107 1541 : newline_and_indent (pp, spc + 2);
4108 1541 : pp_left_brace (pp);
4109 1541 : newline_and_indent (pp, spc + 4);
4110 1541 : dump_generic_node (pp, OMP_BODY (node), spc + 4, flags, false);
4111 1541 : newline_and_indent (pp, spc + 2);
4112 1541 : pp_right_brace (pp);
4113 : }
4114 : is_expr = false;
4115 : break;
4116 :
4117 161 : case OMP_TASK:
4118 162 : pp_string (pp, OMP_TASK_BODY (node) ? "#pragma omp task"
4119 : : "#pragma omp taskwait");
4120 161 : dump_omp_clauses (pp, OMP_TASK_CLAUSES (node), spc, flags);
4121 161 : goto dump_omp_body;
4122 :
4123 252 : case OMP_FOR:
4124 252 : pp_string (pp, "#pragma omp for");
4125 252 : goto dump_omp_loop;
4126 :
4127 235 : case OMP_SIMD:
4128 235 : pp_string (pp, "#pragma omp simd");
4129 235 : goto dump_omp_loop;
4130 :
4131 66 : case OMP_DISTRIBUTE:
4132 66 : pp_string (pp, "#pragma omp distribute");
4133 66 : goto dump_omp_loop;
4134 :
4135 5 : case OMP_TASKLOOP:
4136 5 : pp_string (pp, "#pragma omp taskloop");
4137 5 : goto dump_omp_loop;
4138 :
4139 26 : case OMP_LOOP:
4140 26 : pp_string (pp, "#pragma omp loop");
4141 26 : goto dump_omp_loop;
4142 :
4143 188 : case OMP_TILE:
4144 188 : pp_string (pp, "#pragma omp tile");
4145 188 : goto dump_omp_loop;
4146 :
4147 196 : case OMP_UNROLL:
4148 196 : pp_string (pp, "#pragma omp unroll");
4149 196 : goto dump_omp_loop;
4150 :
4151 307 : case OACC_LOOP:
4152 307 : pp_string (pp, "#pragma acc loop");
4153 307 : goto dump_omp_loop;
4154 :
4155 100 : case OMP_TEAMS:
4156 100 : pp_string (pp, "#pragma omp teams");
4157 100 : dump_omp_clauses (pp, OMP_TEAMS_CLAUSES (node), spc, flags);
4158 100 : goto dump_omp_body;
4159 :
4160 70 : case OMP_TARGET_DATA:
4161 70 : pp_string (pp, "#pragma omp target data");
4162 70 : dump_omp_clauses (pp, OMP_TARGET_DATA_CLAUSES (node), spc, flags);
4163 70 : goto dump_omp_body;
4164 :
4165 71 : case OMP_TARGET_ENTER_DATA:
4166 71 : pp_string (pp, "#pragma omp target enter data");
4167 71 : dump_omp_clauses (pp, OMP_TARGET_ENTER_DATA_CLAUSES (node), spc, flags);
4168 71 : is_expr = false;
4169 71 : break;
4170 :
4171 57 : case OMP_TARGET_EXIT_DATA:
4172 57 : pp_string (pp, "#pragma omp target exit data");
4173 57 : dump_omp_clauses (pp, OMP_TARGET_EXIT_DATA_CLAUSES (node), spc, flags);
4174 57 : is_expr = false;
4175 57 : break;
4176 :
4177 518 : case OMP_TARGET:
4178 518 : pp_string (pp, "#pragma omp target");
4179 518 : dump_omp_clauses (pp, OMP_TARGET_CLAUSES (node), spc, flags);
4180 518 : goto dump_omp_body;
4181 :
4182 42 : case OMP_TARGET_UPDATE:
4183 42 : pp_string (pp, "#pragma omp target update");
4184 42 : dump_omp_clauses (pp, OMP_TARGET_UPDATE_CLAUSES (node), spc, flags);
4185 42 : is_expr = false;
4186 42 : break;
4187 :
4188 1275 : dump_omp_loop:
4189 1275 : dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
4190 1275 : if (!(flags & TDF_SLIM))
4191 : {
4192 1275 : int i;
4193 :
4194 1275 : if (OMP_FOR_PRE_BODY (node))
4195 : {
4196 378 : newline_and_indent (pp, spc + 2);
4197 378 : pp_left_brace (pp);
4198 378 : spc += 4;
4199 378 : newline_and_indent (pp, spc);
4200 378 : dump_generic_node (pp, OMP_FOR_PRE_BODY (node),
4201 : spc, flags, false);
4202 : }
4203 1275 : if (OMP_FOR_INIT (node))
4204 : {
4205 1162 : spc -= 2;
4206 2582 : for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
4207 : {
4208 1420 : if (TREE_VEC_ELT (OMP_FOR_INIT (node), i) == NULL_TREE)
4209 297 : continue;
4210 1123 : spc += 2;
4211 1123 : newline_and_indent (pp, spc);
4212 1123 : pp_string (pp, "for (");
4213 1123 : tree init = TREE_VEC_ELT (OMP_FOR_INIT (node), i);
4214 1123 : if (TREE_CODE (init) != MODIFY_EXPR
4215 1123 : || TREE_CODE (TREE_OPERAND (init, 1)) != TREE_VEC)
4216 1076 : dump_generic_node (pp, init, spc, flags, false);
4217 : else
4218 : {
4219 47 : dump_generic_node (pp, TREE_OPERAND (init, 0),
4220 : spc, flags, false);
4221 47 : pp_string (pp, " = ");
4222 47 : dump_omp_loop_non_rect_expr (pp, TREE_OPERAND (init, 1),
4223 : spc, flags);
4224 : }
4225 1123 : pp_string (pp, "; ");
4226 1123 : tree cond = TREE_VEC_ELT (OMP_FOR_COND (node), i);
4227 1123 : if (!COMPARISON_CLASS_P (cond)
4228 1123 : || TREE_CODE (TREE_OPERAND (cond, 1)) != TREE_VEC)
4229 1082 : dump_generic_node (pp, cond, spc, flags, false);
4230 : else
4231 : {
4232 41 : dump_generic_node (pp, TREE_OPERAND (cond, 0),
4233 : spc, flags, false);
4234 82 : const char *op = op_symbol (cond);
4235 41 : pp_space (pp);
4236 41 : pp_string (pp, op);
4237 41 : pp_space (pp);
4238 41 : dump_omp_loop_non_rect_expr (pp, TREE_OPERAND (cond, 1),
4239 : spc, flags);
4240 : }
4241 1123 : pp_string (pp, "; ");
4242 1123 : dump_generic_node (pp,
4243 1123 : TREE_VEC_ELT (OMP_FOR_INCR (node), i),
4244 : spc, flags, false);
4245 1123 : pp_right_paren (pp);
4246 : }
4247 : }
4248 1275 : if (OMP_FOR_BODY (node))
4249 : {
4250 1275 : newline_and_indent (pp, spc + 2);
4251 1275 : pp_left_brace (pp);
4252 1275 : newline_and_indent (pp, spc + 4);
4253 1275 : dump_generic_node (pp, OMP_FOR_BODY (node), spc + 4, flags,
4254 : false);
4255 1275 : newline_and_indent (pp, spc + 2);
4256 1275 : pp_right_brace (pp);
4257 : }
4258 1275 : if (OMP_FOR_INIT (node))
4259 1162 : spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
4260 1275 : if (OMP_FOR_PRE_BODY (node))
4261 : {
4262 378 : spc -= 4;
4263 378 : newline_and_indent (pp, spc + 2);
4264 378 : pp_right_brace (pp);
4265 : }
4266 : }
4267 : is_expr = false;
4268 : break;
4269 :
4270 10 : case OMP_SECTIONS:
4271 10 : pp_string (pp, "#pragma omp sections");
4272 10 : dump_omp_clauses (pp, OMP_SECTIONS_CLAUSES (node), spc, flags);
4273 10 : goto dump_omp_body;
4274 :
4275 57 : case OMP_DISPATCH:
4276 57 : pp_string (pp, "#pragma omp dispatch");
4277 57 : dump_omp_clauses (pp, OMP_DISPATCH_CLAUSES (node), spc, flags);
4278 57 : goto dump_omp_body;
4279 :
4280 65 : case OMP_INTEROP:
4281 65 : pp_string (pp, "#pragma omp interop");
4282 65 : dump_omp_clauses (pp, OMP_INTEROP_CLAUSES (node), spc, flags);
4283 65 : is_expr = false;
4284 65 : break;
4285 :
4286 14 : case OMP_SECTION:
4287 14 : pp_string (pp, "#pragma omp section");
4288 14 : goto dump_omp_body;
4289 :
4290 10 : case OMP_STRUCTURED_BLOCK:
4291 10 : pp_string (pp, "#pragma omp __structured_block");
4292 10 : goto dump_omp_body;
4293 :
4294 10 : case OMP_SCAN:
4295 10 : if (OMP_SCAN_CLAUSES (node))
4296 : {
4297 5 : pp_string (pp, "#pragma omp scan");
4298 5 : dump_omp_clauses (pp, OMP_SCAN_CLAUSES (node), spc, flags);
4299 : }
4300 10 : goto dump_omp_body;
4301 :
4302 4 : case OMP_MASTER:
4303 4 : pp_string (pp, "#pragma omp master");
4304 4 : goto dump_omp_body;
4305 :
4306 1 : case OMP_MASKED:
4307 1 : pp_string (pp, "#pragma omp masked");
4308 1 : dump_omp_clauses (pp, OMP_MASKED_CLAUSES (node), spc, flags);
4309 1 : goto dump_omp_body;
4310 :
4311 5 : case OMP_TASKGROUP:
4312 5 : pp_string (pp, "#pragma omp taskgroup");
4313 5 : dump_omp_clauses (pp, OMP_TASKGROUP_CLAUSES (node), spc, flags);
4314 5 : goto dump_omp_body;
4315 :
4316 18 : case OMP_ORDERED:
4317 18 : pp_string (pp, "#pragma omp ordered");
4318 18 : dump_omp_clauses (pp, OMP_ORDERED_CLAUSES (node), spc, flags);
4319 18 : goto dump_omp_body;
4320 :
4321 27 : case OMP_CRITICAL:
4322 27 : pp_string (pp, "#pragma omp critical");
4323 27 : if (OMP_CRITICAL_NAME (node))
4324 : {
4325 24 : pp_space (pp);
4326 24 : pp_left_paren (pp);
4327 24 : dump_generic_node (pp, OMP_CRITICAL_NAME (node), spc,
4328 : flags, false);
4329 24 : pp_right_paren (pp);
4330 : }
4331 27 : dump_omp_clauses (pp, OMP_CRITICAL_CLAUSES (node), spc, flags);
4332 27 : goto dump_omp_body;
4333 :
4334 191 : case OMP_ATOMIC:
4335 191 : pp_string (pp, "#pragma omp atomic");
4336 191 : if (OMP_ATOMIC_WEAK (node))
4337 0 : pp_string (pp, " weak");
4338 191 : dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
4339 191 : newline_and_indent (pp, spc + 2);
4340 191 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4341 191 : pp_space (pp);
4342 191 : pp_equal (pp);
4343 191 : pp_space (pp);
4344 191 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4345 191 : break;
4346 :
4347 42 : case OMP_ATOMIC_READ:
4348 42 : pp_string (pp, "#pragma omp atomic read");
4349 42 : dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
4350 42 : newline_and_indent (pp, spc + 2);
4351 42 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4352 42 : pp_space (pp);
4353 42 : break;
4354 :
4355 56 : case OMP_ATOMIC_CAPTURE_OLD:
4356 56 : case OMP_ATOMIC_CAPTURE_NEW:
4357 56 : pp_string (pp, "#pragma omp atomic capture");
4358 56 : if (OMP_ATOMIC_WEAK (node))
4359 0 : pp_string (pp, " weak");
4360 56 : dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
4361 56 : newline_and_indent (pp, spc + 2);
4362 56 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4363 56 : pp_space (pp);
4364 56 : pp_equal (pp);
4365 56 : pp_space (pp);
4366 56 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4367 56 : break;
4368 :
4369 17 : case OMP_SINGLE:
4370 17 : pp_string (pp, "#pragma omp single");
4371 17 : dump_omp_clauses (pp, OMP_SINGLE_CLAUSES (node), spc, flags);
4372 17 : goto dump_omp_body;
4373 :
4374 2 : case OMP_SCOPE:
4375 2 : pp_string (pp, "#pragma omp scope");
4376 2 : dump_omp_clauses (pp, OMP_SCOPE_CLAUSES (node), spc, flags);
4377 2 : goto dump_omp_body;
4378 :
4379 1590 : case OMP_CLAUSE:
4380 : /* If we come here, we're dumping something that's not an OMP construct,
4381 : for example, OMP clauses attached to a function's '__attribute__'.
4382 : Dump the whole OMP clause chain. */
4383 1590 : dump_omp_clauses (pp, node, spc, flags, false);
4384 1590 : is_expr = false;
4385 1590 : break;
4386 :
4387 34 : case OMP_METADIRECTIVE:
4388 34 : {
4389 34 : pp_string (pp, "#pragma omp metadirective");
4390 34 : newline_and_indent (pp, spc + 2);
4391 34 : pp_left_brace (pp);
4392 :
4393 34 : tree variant = OMP_METADIRECTIVE_VARIANTS (node);
4394 120 : while (variant != NULL_TREE)
4395 : {
4396 86 : tree selector = OMP_METADIRECTIVE_VARIANT_SELECTOR (variant);
4397 86 : tree directive = OMP_METADIRECTIVE_VARIANT_DIRECTIVE (variant);
4398 86 : tree body = OMP_METADIRECTIVE_VARIANT_BODY (variant);
4399 :
4400 86 : newline_and_indent (pp, spc + 4);
4401 86 : if (selector == NULL_TREE)
4402 34 : pp_string (pp, "otherwise:");
4403 : else
4404 : {
4405 52 : pp_string (pp, "when (");
4406 52 : dump_omp_context_selector (pp, selector, spc + 4, flags);
4407 52 : pp_string (pp, "):");
4408 : }
4409 86 : newline_and_indent (pp, spc + 6);
4410 :
4411 86 : dump_generic_node (pp, directive, spc + 6, flags, false);
4412 86 : newline_and_indent (pp, spc + 6);
4413 86 : dump_generic_node (pp, body, spc + 6, flags, false);
4414 86 : variant = TREE_CHAIN (variant);
4415 : }
4416 34 : newline_and_indent (pp, spc + 2);
4417 34 : pp_right_brace (pp);
4418 : }
4419 34 : break;
4420 :
4421 12 : case OMP_NEXT_VARIANT:
4422 12 : {
4423 12 : pp_string (pp, "OMP_NEXT_VARIANT <");
4424 12 : dump_generic_node (pp, OMP_NEXT_VARIANT_INDEX (node), spc,
4425 : flags, false);
4426 12 : pp_string (pp, ", ");
4427 12 : tree state = OMP_NEXT_VARIANT_STATE (node);
4428 12 : gcc_assert (state && TREE_CODE (state) == TREE_LIST);
4429 12 : if (TREE_PURPOSE (state))
4430 : {
4431 0 : newline_and_indent (pp, spc + 2);
4432 0 : pp_string (pp, "resolution map = ");
4433 0 : dump_generic_node (pp, TREE_PURPOSE (state), spc, flags, false);
4434 : }
4435 12 : newline_and_indent (pp, spc + 2);
4436 12 : pp_string (pp, "construct context = ");
4437 12 : if (TREE_VALUE (state))
4438 0 : dump_generic_node (pp, TREE_VALUE (state), spc, flags, false);
4439 : else
4440 12 : pp_string (pp, "NULL");
4441 :
4442 12 : tree selectors = TREE_CHAIN (state);
4443 60 : for (int i = 0; i < TREE_VEC_LENGTH (selectors); i++)
4444 : {
4445 48 : newline_and_indent (pp, spc + 2);
4446 48 : pp_decimal_int (pp, i + 1);
4447 48 : pp_string (pp, ": ");
4448 48 : dump_omp_context_selector (pp, TREE_VEC_ELT (selectors, i),
4449 : spc + 4, flags);
4450 : }
4451 12 : pp_string (pp, ">");
4452 : }
4453 12 : break;
4454 :
4455 0 : case OMP_TARGET_DEVICE_MATCHES:
4456 0 : pp_string (pp, "OMP_TARGET_DEVICE_MATCHES <");
4457 0 : dump_generic_node (pp, OMP_TARGET_DEVICE_MATCHES_SELECTOR (node), spc,
4458 : flags, false);
4459 0 : for (tree p = OMP_TARGET_DEVICE_MATCHES_PROPERTIES (node);
4460 0 : p; p = TREE_CHAIN (p))
4461 : {
4462 0 : pp_string (pp, ", ");
4463 0 : dump_generic_node (pp, OMP_TP_VALUE (p), spc, flags, false);
4464 : }
4465 0 : pp_string (pp, ")>");
4466 0 : break;
4467 :
4468 52 : case OMP_DECLARE_MAPPER:
4469 52 : pp_string (pp, "#pragma omp declare mapper (");
4470 52 : if (OMP_DECLARE_MAPPER_ID (node))
4471 : {
4472 8 : dump_generic_node (pp, OMP_DECLARE_MAPPER_ID (node), spc, flags,
4473 : false);
4474 8 : pp_colon (pp);
4475 : }
4476 52 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
4477 52 : pp_space (pp);
4478 52 : dump_generic_node (pp, OMP_DECLARE_MAPPER_DECL (node), spc, flags, false);
4479 52 : pp_right_paren (pp);
4480 52 : dump_omp_clauses (pp, OMP_DECLARE_MAPPER_CLAUSES (node), spc, flags);
4481 52 : break;
4482 :
4483 0 : case TRANSACTION_EXPR:
4484 0 : if (TRANSACTION_EXPR_OUTER (node))
4485 0 : pp_string (pp, "__transaction_atomic [[outer]]");
4486 0 : else if (TRANSACTION_EXPR_RELAXED (node))
4487 0 : pp_string (pp, "__transaction_relaxed");
4488 : else
4489 0 : pp_string (pp, "__transaction_atomic");
4490 0 : if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
4491 : {
4492 0 : newline_and_indent (pp, spc);
4493 0 : pp_left_brace (pp);
4494 0 : newline_and_indent (pp, spc + 2);
4495 0 : dump_generic_node (pp, TRANSACTION_EXPR_BODY (node),
4496 : spc + 2, flags, false);
4497 0 : newline_and_indent (pp, spc);
4498 0 : pp_right_brace (pp);
4499 : }
4500 : is_expr = false;
4501 : break;
4502 :
4503 0 : case VEC_SERIES_EXPR:
4504 0 : case VEC_WIDEN_MULT_HI_EXPR:
4505 0 : case VEC_WIDEN_MULT_LO_EXPR:
4506 0 : case VEC_WIDEN_MULT_EVEN_EXPR:
4507 0 : case VEC_WIDEN_MULT_ODD_EXPR:
4508 0 : case VEC_WIDEN_LSHIFT_HI_EXPR:
4509 0 : case VEC_WIDEN_LSHIFT_LO_EXPR:
4510 0 : pp_space (pp);
4511 0 : for (str = get_tree_code_name (code); *str; str++)
4512 0 : pp_character (pp, TOUPPER (*str));
4513 0 : pp_string (pp, " < ");
4514 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4515 0 : pp_string (pp, ", ");
4516 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4517 0 : pp_string (pp, " > ");
4518 0 : break;
4519 :
4520 0 : case VEC_DUPLICATE_EXPR:
4521 0 : pp_space (pp);
4522 0 : for (str = get_tree_code_name (code); *str; str++)
4523 0 : pp_character (pp, TOUPPER (*str));
4524 0 : pp_string (pp, " < ");
4525 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4526 0 : pp_string (pp, " > ");
4527 0 : break;
4528 :
4529 0 : case VEC_UNPACK_HI_EXPR:
4530 0 : pp_string (pp, " VEC_UNPACK_HI_EXPR < ");
4531 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4532 0 : pp_string (pp, " > ");
4533 0 : break;
4534 :
4535 0 : case VEC_UNPACK_LO_EXPR:
4536 0 : pp_string (pp, " VEC_UNPACK_LO_EXPR < ");
4537 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4538 0 : pp_string (pp, " > ");
4539 0 : break;
4540 :
4541 0 : case VEC_UNPACK_FLOAT_HI_EXPR:
4542 0 : pp_string (pp, " VEC_UNPACK_FLOAT_HI_EXPR < ");
4543 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4544 0 : pp_string (pp, " > ");
4545 0 : break;
4546 :
4547 0 : case VEC_UNPACK_FLOAT_LO_EXPR:
4548 0 : pp_string (pp, " VEC_UNPACK_FLOAT_LO_EXPR < ");
4549 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4550 0 : pp_string (pp, " > ");
4551 0 : break;
4552 :
4553 0 : case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
4554 0 : pp_string (pp, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
4555 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4556 0 : pp_string (pp, " > ");
4557 0 : break;
4558 :
4559 0 : case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
4560 0 : pp_string (pp, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
4561 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4562 0 : pp_string (pp, " > ");
4563 0 : break;
4564 :
4565 0 : case VEC_PACK_TRUNC_EXPR:
4566 0 : pp_string (pp, " VEC_PACK_TRUNC_EXPR < ");
4567 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4568 0 : pp_string (pp, ", ");
4569 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4570 0 : pp_string (pp, " > ");
4571 0 : break;
4572 :
4573 0 : case VEC_PACK_SAT_EXPR:
4574 0 : pp_string (pp, " VEC_PACK_SAT_EXPR < ");
4575 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4576 0 : pp_string (pp, ", ");
4577 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4578 0 : pp_string (pp, " > ");
4579 0 : break;
4580 :
4581 0 : case VEC_PACK_FIX_TRUNC_EXPR:
4582 0 : pp_string (pp, " VEC_PACK_FIX_TRUNC_EXPR < ");
4583 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4584 0 : pp_string (pp, ", ");
4585 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4586 0 : pp_string (pp, " > ");
4587 0 : break;
4588 :
4589 0 : case VEC_PACK_FLOAT_EXPR:
4590 0 : pp_string (pp, " VEC_PACK_FLOAT_EXPR < ");
4591 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4592 0 : pp_string (pp, ", ");
4593 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4594 0 : pp_string (pp, " > ");
4595 0 : break;
4596 :
4597 6 : case BLOCK:
4598 6 : dump_block_node (pp, node, spc, flags);
4599 6 : break;
4600 :
4601 888 : case DEBUG_BEGIN_STMT:
4602 888 : pp_string (pp, "# DEBUG BEGIN STMT");
4603 888 : break;
4604 :
4605 13331 : default:
4606 13331 : NIY;
4607 : }
4608 :
4609 49698472 : if (is_stmt && is_expr)
4610 330844 : pp_semicolon (pp);
4611 :
4612 : return spc;
4613 : }
4614 :
4615 : /* Print the declaration of a variable. */
4616 :
4617 : void
4618 463999 : print_declaration (pretty_printer *pp, tree t, int spc, dump_flags_t flags)
4619 : {
4620 2329935 : INDENT (spc);
4621 :
4622 463999 : if (TREE_CODE(t) == NAMELIST_DECL)
4623 : {
4624 1 : pp_string(pp, "namelist ");
4625 1 : dump_decl_name (pp, t, flags);
4626 1 : pp_semicolon (pp);
4627 1 : return;
4628 : }
4629 :
4630 463998 : if (TREE_CODE (t) == TYPE_DECL)
4631 2430 : pp_string (pp, "typedef ");
4632 :
4633 463998 : if (HAS_RTL_P (t) && DECL_REGISTER (t))
4634 39 : pp_string (pp, "register ");
4635 :
4636 463998 : if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
4637 5180 : pp_string (pp, "extern ");
4638 458818 : else if (TREE_STATIC (t))
4639 16875 : pp_string (pp, "static ");
4640 :
4641 : /* Print the type and name. */
4642 463998 : if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
4643 : {
4644 26638 : tree tmp;
4645 :
4646 : /* Print array's type. */
4647 26638 : tmp = TREE_TYPE (t);
4648 27484 : while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
4649 846 : tmp = TREE_TYPE (tmp);
4650 26638 : dump_generic_node (pp, TREE_TYPE (tmp), spc, flags, false);
4651 :
4652 : /* Print variable's name. */
4653 26638 : pp_space (pp);
4654 26638 : dump_generic_node (pp, t, spc, flags, false);
4655 :
4656 : /* Print the dimensions. */
4657 26638 : tmp = TREE_TYPE (t);
4658 54122 : while (TREE_CODE (tmp) == ARRAY_TYPE)
4659 : {
4660 27484 : dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
4661 27484 : tmp = TREE_TYPE (tmp);
4662 : }
4663 : }
4664 437360 : else if (TREE_CODE (t) == FUNCTION_DECL)
4665 : {
4666 8906 : dump_generic_node (pp, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
4667 8906 : pp_space (pp);
4668 8906 : dump_decl_name (pp, t, flags);
4669 8906 : dump_function_declaration (pp, TREE_TYPE (t), spc, flags);
4670 : }
4671 : else
4672 : {
4673 : /* Print type declaration. */
4674 428454 : dump_generic_node (pp, TREE_TYPE (t), spc, flags, false);
4675 :
4676 : /* Print variable's name. */
4677 428454 : pp_space (pp);
4678 428454 : dump_generic_node (pp, t, spc, flags, false);
4679 : }
4680 :
4681 463998 : if (VAR_P (t) && DECL_HARD_REGISTER (t))
4682 : {
4683 5 : pp_string (pp, " __asm__ ");
4684 5 : pp_left_paren (pp);
4685 5 : dump_generic_node (pp, DECL_ASSEMBLER_NAME (t), spc, flags, false);
4686 5 : pp_right_paren (pp);
4687 : }
4688 :
4689 : /* The initial value of a function serves to determine whether the function
4690 : is declared or defined. So the following does not apply to function
4691 : nodes. */
4692 463998 : if (TREE_CODE (t) != FUNCTION_DECL)
4693 : {
4694 : /* Print the initial value. */
4695 455092 : if (DECL_INITIAL (t))
4696 : {
4697 22097 : pp_space (pp);
4698 22097 : pp_equal (pp);
4699 22097 : pp_space (pp);
4700 22097 : if (!(flags & TDF_SLIM))
4701 21307 : dump_generic_node (pp, DECL_INITIAL (t), spc, flags, false);
4702 : else
4703 790 : pp_string (pp, "<<< omitted >>>");
4704 : }
4705 : }
4706 :
4707 463998 : if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t))
4708 : {
4709 2404 : pp_string (pp, " [value-expr: ");
4710 2404 : dump_generic_node (pp, DECL_VALUE_EXPR (t), spc, flags, false);
4711 2404 : pp_right_bracket (pp);
4712 : }
4713 :
4714 463998 : pp_semicolon (pp);
4715 : }
4716 :
4717 :
4718 : /* Prints a structure: name, fields, and methods.
4719 : FIXME: Still incomplete. */
4720 :
4721 : static void
4722 580 : print_struct_decl (pretty_printer *pp, const_tree node, int spc,
4723 : dump_flags_t flags)
4724 : {
4725 : /* Print the name of the structure. */
4726 580 : if (TYPE_NAME (node))
4727 : {
4728 0 : INDENT (spc);
4729 0 : if (TREE_CODE (node) == RECORD_TYPE)
4730 0 : pp_string (pp, "struct ");
4731 0 : else if ((TREE_CODE (node) == UNION_TYPE
4732 0 : || TREE_CODE (node) == QUAL_UNION_TYPE))
4733 0 : pp_string (pp, "union ");
4734 :
4735 0 : dump_generic_node (pp, TYPE_NAME (node), spc, TDF_NONE, false);
4736 : }
4737 :
4738 : /* Print the contents of the structure. */
4739 580 : pp_newline (pp);
4740 1908 : INDENT (spc);
4741 580 : pp_left_brace (pp);
4742 580 : pp_newline (pp);
4743 :
4744 : /* Print the fields of the structure. */
4745 580 : {
4746 580 : tree tmp;
4747 580 : tmp = TYPE_FIELDS (node);
4748 3177 : while (tmp)
4749 : {
4750 : /* Avoid to print recursively the structure. */
4751 : /* FIXME : Not implemented correctly...,
4752 : what about the case when we have a cycle in the contain graph? ...
4753 : Maybe this could be solved by looking at the scope in which the
4754 : structure was declared. */
4755 2597 : if (TREE_TYPE (tmp) != node
4756 2597 : && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
4757 52 : || TREE_TYPE (TREE_TYPE (tmp)) != node))
4758 : {
4759 2597 : print_declaration (pp, tmp, spc+2, flags);
4760 2597 : pp_newline (pp);
4761 : }
4762 2597 : tmp = DECL_CHAIN (tmp);
4763 : }
4764 : }
4765 1328 : INDENT (spc);
4766 580 : pp_right_brace (pp);
4767 580 : }
4768 :
4769 : /* Return the priority of the operator CODE.
4770 :
4771 : From lowest to highest precedence with either left-to-right (L-R)
4772 : or right-to-left (R-L) associativity]:
4773 :
4774 : 1 [L-R] ,
4775 : 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
4776 : 3 [R-L] ?:
4777 : 4 [L-R] ||
4778 : 5 [L-R] &&
4779 : 6 [L-R] |
4780 : 7 [L-R] ^
4781 : 8 [L-R] &
4782 : 9 [L-R] == !=
4783 : 10 [L-R] < <= > >=
4784 : 11 [L-R] << >>
4785 : 12 [L-R] + -
4786 : 13 [L-R] * / %
4787 : 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
4788 : 15 [L-R] fn() [] -> .
4789 :
4790 : unary +, - and * have higher precedence than the corresponding binary
4791 : operators. */
4792 :
4793 : int
4794 22488202 : op_code_prio (enum tree_code code)
4795 : {
4796 22488202 : switch (code)
4797 : {
4798 : case TREE_LIST:
4799 : case COMPOUND_EXPR:
4800 : case BIND_EXPR:
4801 : return 1;
4802 :
4803 : case MODIFY_EXPR:
4804 : case INIT_EXPR:
4805 : return 2;
4806 :
4807 : case COND_EXPR:
4808 : return 3;
4809 :
4810 : case TRUTH_OR_EXPR:
4811 : case TRUTH_ORIF_EXPR:
4812 : return 4;
4813 :
4814 : case TRUTH_AND_EXPR:
4815 : case TRUTH_ANDIF_EXPR:
4816 : return 5;
4817 :
4818 : case BIT_IOR_EXPR:
4819 : return 6;
4820 :
4821 : case BIT_XOR_EXPR:
4822 : case TRUTH_XOR_EXPR:
4823 : return 7;
4824 :
4825 : case BIT_AND_EXPR:
4826 : return 8;
4827 :
4828 : case EQ_EXPR:
4829 : case NE_EXPR:
4830 : return 9;
4831 :
4832 : case UNLT_EXPR:
4833 : case UNLE_EXPR:
4834 : case UNGT_EXPR:
4835 : case UNGE_EXPR:
4836 : case UNEQ_EXPR:
4837 : case LTGT_EXPR:
4838 : case ORDERED_EXPR:
4839 : case UNORDERED_EXPR:
4840 : case LT_EXPR:
4841 : case LE_EXPR:
4842 : case GT_EXPR:
4843 : case GE_EXPR:
4844 : return 10;
4845 :
4846 : case LSHIFT_EXPR:
4847 : case RSHIFT_EXPR:
4848 : case LROTATE_EXPR:
4849 : case RROTATE_EXPR:
4850 : case VEC_WIDEN_LSHIFT_HI_EXPR:
4851 : case VEC_WIDEN_LSHIFT_LO_EXPR:
4852 : case WIDEN_LSHIFT_EXPR:
4853 : return 11;
4854 :
4855 : case WIDEN_SUM_EXPR:
4856 : case PLUS_EXPR:
4857 : case POINTER_PLUS_EXPR:
4858 : case POINTER_DIFF_EXPR:
4859 : case MINUS_EXPR:
4860 : return 12;
4861 :
4862 : case VEC_WIDEN_MULT_HI_EXPR:
4863 : case VEC_WIDEN_MULT_LO_EXPR:
4864 : case WIDEN_MULT_EXPR:
4865 : case DOT_PROD_EXPR:
4866 : case WIDEN_MULT_PLUS_EXPR:
4867 : case WIDEN_MULT_MINUS_EXPR:
4868 : case MULT_EXPR:
4869 : case MULT_HIGHPART_EXPR:
4870 : case TRUNC_DIV_EXPR:
4871 : case CEIL_DIV_EXPR:
4872 : case FLOOR_DIV_EXPR:
4873 : case ROUND_DIV_EXPR:
4874 : case RDIV_EXPR:
4875 : case EXACT_DIV_EXPR:
4876 : case TRUNC_MOD_EXPR:
4877 : case CEIL_MOD_EXPR:
4878 : case FLOOR_MOD_EXPR:
4879 : case ROUND_MOD_EXPR:
4880 : return 13;
4881 :
4882 : case TRUTH_NOT_EXPR:
4883 : case BIT_NOT_EXPR:
4884 : case POSTINCREMENT_EXPR:
4885 : case POSTDECREMENT_EXPR:
4886 : case PREINCREMENT_EXPR:
4887 : case PREDECREMENT_EXPR:
4888 : case NEGATE_EXPR:
4889 : case INDIRECT_REF:
4890 : case ADDR_EXPR:
4891 : case FLOAT_EXPR:
4892 : CASE_CONVERT:
4893 : case FIX_TRUNC_EXPR:
4894 : case TARGET_EXPR:
4895 : return 14;
4896 :
4897 : case CALL_EXPR:
4898 : case ARRAY_REF:
4899 : case ARRAY_RANGE_REF:
4900 : case COMPONENT_REF:
4901 : return 15;
4902 :
4903 : /* Special expressions. */
4904 : case MIN_EXPR:
4905 : case MAX_EXPR:
4906 : case ABS_EXPR:
4907 : case REALPART_EXPR:
4908 : case IMAGPART_EXPR:
4909 : case VEC_UNPACK_HI_EXPR:
4910 : case VEC_UNPACK_LO_EXPR:
4911 : case VEC_UNPACK_FLOAT_HI_EXPR:
4912 : case VEC_UNPACK_FLOAT_LO_EXPR:
4913 : case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
4914 : case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
4915 : case VEC_PACK_TRUNC_EXPR:
4916 : case VEC_PACK_SAT_EXPR:
4917 : return 16;
4918 :
4919 : default:
4920 : /* Return an arbitrarily high precedence to avoid surrounding single
4921 : VAR_DECLs in ()s. */
4922 : return 9999;
4923 : }
4924 : }
4925 :
4926 : /* Return the priority of the operator OP. */
4927 :
4928 : int
4929 17846725 : op_prio (const_tree op)
4930 : {
4931 17863677 : enum tree_code code;
4932 :
4933 17863677 : if (op == NULL)
4934 : return 9999;
4935 :
4936 17863455 : code = TREE_CODE (op);
4937 17863455 : if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
4938 16952 : return op_prio (TREE_OPERAND (op, 0));
4939 :
4940 17846503 : return op_code_prio (code);
4941 : }
4942 :
4943 : /* Return the symbol associated with operator CODE. */
4944 :
4945 : const char *
4946 2837690 : op_symbol_code (enum tree_code code, dump_flags_t flags)
4947 : {
4948 2837690 : switch (code)
4949 : {
4950 : case MODIFY_EXPR:
4951 : return "=";
4952 :
4953 2529 : case TRUTH_OR_EXPR:
4954 2529 : case TRUTH_ORIF_EXPR:
4955 2529 : return "||";
4956 :
4957 2832 : case TRUTH_AND_EXPR:
4958 2832 : case TRUTH_ANDIF_EXPR:
4959 2832 : return "&&";
4960 :
4961 36379 : case BIT_IOR_EXPR:
4962 36379 : return "|";
4963 :
4964 27291 : case TRUTH_XOR_EXPR:
4965 27291 : case BIT_XOR_EXPR:
4966 27291 : return "^";
4967 :
4968 388947 : case ADDR_EXPR:
4969 388947 : case BIT_AND_EXPR:
4970 388947 : return "&";
4971 :
4972 37 : case ORDERED_EXPR:
4973 37 : return (flags & TDF_GIMPLE) ? "__ORDERED" : "ord";
4974 63 : case UNORDERED_EXPR:
4975 63 : return (flags & TDF_GIMPLE) ? "__UNORDERED" : "unord";
4976 :
4977 68060 : case EQ_EXPR:
4978 68060 : return "==";
4979 151 : case UNEQ_EXPR:
4980 151 : return (flags & TDF_GIMPLE) ? "__UNEQ" : "u==";
4981 :
4982 215499 : case NE_EXPR:
4983 215499 : return "!=";
4984 :
4985 73521 : case LT_EXPR:
4986 73521 : return "<";
4987 190 : case UNLT_EXPR:
4988 190 : return (flags & TDF_GIMPLE) ? "__UNLT" : "u<";
4989 :
4990 31825 : case LE_EXPR:
4991 31825 : return "<=";
4992 224 : case UNLE_EXPR:
4993 224 : return (flags & TDF_GIMPLE) ? "__UNLE" : "u<=";
4994 :
4995 58615 : case GT_EXPR:
4996 58615 : return ">";
4997 235 : case UNGT_EXPR:
4998 235 : return (flags & TDF_GIMPLE) ? "__UNGT" : "u>";
4999 :
5000 10475 : case GE_EXPR:
5001 10475 : return ">=";
5002 179 : case UNGE_EXPR:
5003 179 : return (flags & TDF_GIMPLE) ? "__UNGE" : "u>=";
5004 :
5005 24 : case LTGT_EXPR:
5006 24 : return (flags & TDF_GIMPLE) ? "__LTGT" : "<>";
5007 :
5008 46914 : case LSHIFT_EXPR:
5009 46914 : return "<<";
5010 :
5011 106375 : case RSHIFT_EXPR:
5012 106375 : return ">>";
5013 :
5014 785 : case LROTATE_EXPR:
5015 785 : return (flags & TDF_GIMPLE) ? "__ROTATE_LEFT" : "r<<";
5016 :
5017 1381 : case RROTATE_EXPR:
5018 1381 : return (flags & TDF_GIMPLE) ? "__ROTATE_RIGHT" : "r>>";
5019 :
5020 0 : case WIDEN_LSHIFT_EXPR:
5021 0 : return "w<<";
5022 :
5023 : case POINTER_PLUS_EXPR:
5024 : return "+";
5025 :
5026 : case PLUS_EXPR:
5027 : return "+";
5028 :
5029 0 : case WIDEN_SUM_EXPR:
5030 0 : return "w+";
5031 :
5032 11305 : case WIDEN_MULT_EXPR:
5033 11305 : return "w*";
5034 :
5035 7636 : case MULT_HIGHPART_EXPR:
5036 7636 : return (flags & TDF_GIMPLE) ? "__MULT_HIGHPART" : "h*";
5037 :
5038 199687 : case NEGATE_EXPR:
5039 199687 : case MINUS_EXPR:
5040 199687 : case POINTER_DIFF_EXPR:
5041 199687 : return "-";
5042 :
5043 720 : case BIT_NOT_EXPR:
5044 720 : return "~";
5045 :
5046 540 : case TRUTH_NOT_EXPR:
5047 540 : return "!";
5048 :
5049 376445 : case MULT_EXPR:
5050 376445 : case INDIRECT_REF:
5051 376445 : return "*";
5052 :
5053 14038 : case TRUNC_DIV_EXPR:
5054 14038 : case RDIV_EXPR:
5055 14038 : return "/";
5056 :
5057 135 : case CEIL_DIV_EXPR:
5058 135 : return "/[cl]";
5059 :
5060 217 : case FLOOR_DIV_EXPR:
5061 217 : return "/[fl]";
5062 :
5063 126 : case ROUND_DIV_EXPR:
5064 126 : return "/[rd]";
5065 :
5066 544 : case EXACT_DIV_EXPR:
5067 544 : return "/[ex]";
5068 :
5069 6952 : case TRUNC_MOD_EXPR:
5070 6952 : return "%";
5071 :
5072 126 : case CEIL_MOD_EXPR:
5073 126 : return "%[cl]";
5074 :
5075 63 : case FLOOR_MOD_EXPR:
5076 63 : return "%[fl]";
5077 :
5078 126 : case ROUND_MOD_EXPR:
5079 126 : return "%[rd]";
5080 :
5081 53 : case PREDECREMENT_EXPR:
5082 53 : return " --";
5083 :
5084 538 : case PREINCREMENT_EXPR:
5085 538 : return " ++";
5086 :
5087 10 : case POSTDECREMENT_EXPR:
5088 10 : return "-- ";
5089 :
5090 1525 : case POSTINCREMENT_EXPR:
5091 1525 : return "++ ";
5092 :
5093 24 : case MAX_EXPR:
5094 24 : return "max";
5095 :
5096 22 : case MIN_EXPR:
5097 22 : return "min";
5098 :
5099 1422 : default:
5100 1422 : return "<<< ??? >>>";
5101 : }
5102 : }
5103 :
5104 : /* Return the symbol associated with operator OP. */
5105 :
5106 : static const char *
5107 604155 : op_symbol (const_tree op, dump_flags_t flags)
5108 : {
5109 604155 : return op_symbol_code (TREE_CODE (op), flags);
5110 : }
5111 :
5112 : /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
5113 : the gimple_call_fn of a GIMPLE_CALL. */
5114 :
5115 : void
5116 190564 : print_call_name (pretty_printer *pp, tree node, dump_flags_t flags)
5117 : {
5118 190564 : tree op0 = node;
5119 190564 : int spc = 0;
5120 :
5121 190564 : if (TREE_CODE (op0) == NON_LVALUE_EXPR)
5122 4 : op0 = TREE_OPERAND (op0, 0);
5123 :
5124 190564 : again:
5125 376160 : switch (TREE_CODE (op0))
5126 : {
5127 184502 : case VAR_DECL:
5128 184502 : case PARM_DECL:
5129 184502 : case FUNCTION_DECL:
5130 184502 : dump_function_name (pp, op0, flags);
5131 184502 : break;
5132 :
5133 185596 : case ADDR_EXPR:
5134 185596 : case INDIRECT_REF:
5135 185596 : CASE_CONVERT:
5136 185596 : op0 = TREE_OPERAND (op0, 0);
5137 185596 : goto again;
5138 :
5139 0 : case COND_EXPR:
5140 0 : pp_left_paren (pp);
5141 0 : dump_generic_node (pp, TREE_OPERAND (op0, 0), 0, flags, false);
5142 0 : pp_string (pp, ") ? ");
5143 0 : dump_generic_node (pp, TREE_OPERAND (op0, 1), 0, flags, false);
5144 0 : pp_string (pp, " : ");
5145 0 : dump_generic_node (pp, TREE_OPERAND (op0, 2), 0, flags, false);
5146 0 : break;
5147 :
5148 0 : case ARRAY_REF:
5149 0 : if (VAR_P (TREE_OPERAND (op0, 0)))
5150 0 : dump_function_name (pp, TREE_OPERAND (op0, 0), flags);
5151 : else
5152 0 : dump_generic_node (pp, op0, 0, flags, false);
5153 : break;
5154 :
5155 0 : case MEM_REF:
5156 0 : if (integer_zerop (TREE_OPERAND (op0, 1)))
5157 : {
5158 0 : op0 = TREE_OPERAND (op0, 0);
5159 0 : goto again;
5160 : }
5161 : /* Fallthru. */
5162 6060 : case COMPONENT_REF:
5163 6060 : case SSA_NAME:
5164 6060 : case OBJ_TYPE_REF:
5165 6060 : dump_generic_node (pp, op0, 0, flags, false);
5166 6060 : break;
5167 :
5168 2 : default:
5169 2 : NIY;
5170 : }
5171 190564 : }
5172 :
5173 : /* Print the first N characters in the array STR, replacing non-printable
5174 : characters (including embedded nuls) with unambiguous escape sequences. */
5175 :
5176 : void
5177 62309 : pretty_print_string (pretty_printer *pp, const char *str, size_t n)
5178 : {
5179 62309 : if (str == NULL)
5180 : return;
5181 :
5182 1483447 : for ( ; n; --n, ++str)
5183 : {
5184 1421138 : switch (str[0])
5185 : {
5186 26 : case '\b':
5187 26 : pp_string (pp, "\\b");
5188 26 : break;
5189 :
5190 30 : case '\f':
5191 30 : pp_string (pp, "\\f");
5192 30 : break;
5193 :
5194 2942 : case '\n':
5195 2942 : pp_string (pp, "\\n");
5196 2942 : break;
5197 :
5198 18 : case '\r':
5199 18 : pp_string (pp, "\\r");
5200 18 : break;
5201 :
5202 44 : case '\t':
5203 44 : pp_string (pp, "\\t");
5204 44 : break;
5205 :
5206 20 : case '\v':
5207 20 : pp_string (pp, "\\v");
5208 20 : break;
5209 :
5210 51 : case '\\':
5211 51 : pp_string (pp, "\\\\");
5212 51 : break;
5213 :
5214 146 : case '\"':
5215 146 : pp_string (pp, "\\\"");
5216 146 : break;
5217 :
5218 14903 : case '\'':
5219 14903 : pp_string (pp, "\\'");
5220 14903 : break;
5221 :
5222 1402958 : default:
5223 1402958 : if (str[0] || n > 1)
5224 : {
5225 1361989 : if (!ISPRINT (str[0]))
5226 : {
5227 6914 : char buf[5];
5228 6914 : sprintf (buf, "\\x%02x", (unsigned char)str[0]);
5229 6914 : pp_string (pp, buf);
5230 : }
5231 : else
5232 1355075 : pp_character (pp, str[0]);
5233 : break;
5234 : }
5235 : }
5236 : }
5237 : }
5238 :
5239 : static void
5240 7186527 : maybe_init_pretty_print (FILE *file)
5241 : {
5242 7186527 : if (!tree_pp)
5243 : {
5244 19269 : tree_pp = new pretty_printer ();
5245 19269 : pp_needs_newline (tree_pp) = true;
5246 19269 : pp_translate_identifiers (tree_pp) = false;
5247 : }
5248 :
5249 7186527 : tree_pp->set_output_stream (file);
5250 7186527 : }
5251 :
5252 : static void
5253 583305 : newline_and_indent (pretty_printer *pp, int spc)
5254 : {
5255 583305 : pp_newline (pp);
5256 7164346 : INDENT (spc);
5257 583305 : }
5258 :
5259 : /* Print the identifier ID to PRETTY-PRINTER. */
5260 :
5261 : void
5262 16743025 : pp_tree_identifier (pretty_printer *pp, tree id)
5263 : {
5264 16743025 : if (pp_translate_identifiers (pp))
5265 : {
5266 9115096 : const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
5267 9115096 : pp_append_text (pp, text, text + strlen (text));
5268 : }
5269 : else
5270 7627929 : pp_append_text (pp, IDENTIFIER_POINTER (id),
5271 7627929 : IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
5272 16743025 : }
5273 :
5274 : /* A helper function that is used to dump function information before the
5275 : function dump. */
5276 :
5277 : void
5278 62082 : dump_function_header (FILE *dump_file, tree fdecl, dump_flags_t flags)
5279 : {
5280 62082 : const char *dname, *aname;
5281 62082 : struct cgraph_node *node = cgraph_node::get (fdecl);
5282 62082 : struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
5283 :
5284 62082 : dname = lang_hooks.decl_printable_name (fdecl, 1);
5285 :
5286 62082 : if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
5287 62078 : aname = (IDENTIFIER_POINTER
5288 : (DECL_ASSEMBLER_NAME (fdecl)));
5289 : else
5290 : aname = "<unset-asm-name>";
5291 :
5292 62082 : fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
5293 : dname, aname, fun->funcdef_no);
5294 62082 : if (!(flags & TDF_NOUID))
5295 58101 : fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
5296 62082 : if (node)
5297 : {
5298 62082 : fprintf (dump_file, ", cgraph_uid=%d", node->get_uid ());
5299 62082 : fprintf (dump_file, ", symbol_order=%d)%s\n\n", node->order,
5300 62082 : node->frequency == NODE_FREQUENCY_HOT
5301 : ? " (hot)"
5302 : : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
5303 61992 : ? " (unlikely executed)"
5304 : : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
5305 61691 : ? " (executed once)"
5306 : : "");
5307 : }
5308 : else
5309 0 : fprintf (dump_file, ")\n\n");
5310 62082 : }
5311 :
5312 : #if __GNUC__ >= 10
5313 : # pragma GCC diagnostic pop
5314 : #endif
|