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