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