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